
"""simple docstring"""





import copy

from ...configuration_utils import PretrainedConfig
from ...utils import add_start_docstrings


_a														=		R"""
    [`RagConfig`] stores the configuration of a *RagModel*. Configuration objects inherit from [`PretrainedConfig`] and
    can be used to control the model outputs. Read the documentation from [`PretrainedConfig`] for more information.

    Args:
        title_sep (`str`, *optional*, defaults to  `\" / \"`):
            Separator inserted between the title and the text of the retrieved document when calling [`RagRetriever`].
        doc_sep (`str`, *optional*, defaults to  `\" // \"`):
            Separator inserted between the text of the retrieved document and the original input when calling
            [`RagRetriever`].
        n_docs (`int`, *optional*, defaults to 5):
            Number of documents to retrieve.
        max_combined_length (`int`, *optional*, defaults to 300):
            Max length of contextualized input returned by [`~RagRetriever.__call__`].
        retrieval_vector_size (`int`, *optional*, defaults to 768):
            Dimensionality of the document embeddings indexed by [`RagRetriever`].
        retrieval_batch_size (`int`, *optional*, defaults to 8):
            Retrieval batch size, defined as the number of queries issues concurrently to the faiss index encapsulated
            [`RagRetriever`].
        dataset (`str`, *optional*, defaults to `\"wiki_dpr\"`):
            A dataset identifier of the indexed dataset in HuggingFace Datasets (list all available datasets and ids
            using `datasets.list_datasets()`).
        dataset_split (`str`, *optional*, defaults to `\"train\"`)
            Which split of the `dataset` to load.
        index_name (`str`, *optional*, defaults to `\"compressed\"`)
            The index name of the index associated with the `dataset`. One can choose between `\"legacy\"`, `\"exact\"` and
            `\"compressed\"`.
        index_path (`str`, *optional*)
            The path to the serialized faiss index on disk.
        passages_path (`str`, *optional*):
            A path to text passages compatible with the faiss index. Required if using
            [`~models.rag.retrieval_rag.LegacyIndex`]
        use_dummy_dataset (`bool`, *optional*, defaults to `False`)
            Whether to load a \"dummy\" variant of the dataset specified by `dataset`.
        label_smoothing (`float`, *optional*, defaults to 0.0):
            Only relevant if `return_loss` is set to `True`. Controls the `epsilon` parameter value for label smoothing
            in the loss calculation. If set to 0, no label smoothing is performed.
        do_marginalize (`bool`, *optional*, defaults to `False`):
            If `True`, the logits are marginalized over all documents by making use of
            `torch.nn.functional.log_softmax`.
        reduce_loss (`bool`, *optional*, defaults to `False`):
            Whether or not to reduce the NLL loss using the `torch.Tensor.sum` operation.
        do_deduplication (`bool`, *optional*, defaults to `True`):
            Whether or not to deduplicate the generations from different context documents for a given input. Has to be
            set to `False` if used while training with distributed backend.
        exclude_bos_score (`bool`, *optional*, defaults to `False`):
            Whether or not to disregard the BOS token when computing the loss.
        output_retrieved(`bool`, *optional*, defaults to `False`):
            If set to `True`, `retrieved_doc_embeds`, `retrieved_doc_ids`, `context_input_ids` and
            `context_attention_mask` are returned. See returned tensors for more detail.
        use_cache (`bool`, *optional*, defaults to `True`):
            Whether or not the model should return the last key/values attentions (not used by all models).
        forced_eos_token_id (`int`, *optional*):
            The id of the token to force as the last generated token when `max_length` is reached. Usually set to
            `eos_token_id`.
"""






@add_start_docstrings(lowerCamelCase__     )
class    _UpperCAmelCase(   lowerCamelCase__     ):
		lowercase__      =				'rag'
		lowercase__      =				True



		def __init__( self    ,		__a=None    ,		__a=True    ,		__a=None    ,		__a=None    ,		__a=None    ,		__a=None    ,		__a=None    ,		__a=" / "    ,		__a=" // "    ,		__a=5    ,		__a=3_00    ,		__a=7_68    ,		__a=8    ,		__a="wiki_dpr"    ,		__a="train"    ,		__a="compressed"    ,		__a=None    ,		__a=None    ,		__a=False    ,		__a=False    ,		__a=0.0    ,		__a=True    ,		__a=False    ,		__a=False    ,		__a=False    ,		__a=True    ,		__a=None    ,		**__a    ,		)	->	Dict:






							'''simple docstring'''
							super().__init__(
							    bos_token_id=__a    ,		pad_token_id=__a    ,		eos_token_id=__a    ,		decoder_start_token_id=__a    ,		forced_eos_token_id=__a    ,		is_encoder_decoder=__a    ,		prefix=__a    ,		vocab_size=__a    ,		**__a    ,		)
							assert (
							    "question_encoder" in kwargs and "generator" in kwargs
							), "Config has to be initialized with question_encoder and generator config"
							_UpperCamelCase										=  kwargs.pop('''question_encoder''')
							_UpperCamelCase										=  question_encoder_config.pop('''model_type''')
							_UpperCamelCase										=  kwargs.pop('''generator''')
							_UpperCamelCase										=  decoder_config.pop('''model_type''')

							from ..auto.configuration_auto import AutoConfig

							_UpperCamelCase										=  AutoConfig.for_model(__a    ,		**__a)
							_UpperCamelCase										=  AutoConfig.for_model(__a    ,		**__a)

							_UpperCamelCase										=  reduce_loss
							_UpperCamelCase										=  label_smoothing
							_UpperCamelCase										=  exclude_bos_score
							_UpperCamelCase										=  do_marginalize

							_UpperCamelCase										=  title_sep
							_UpperCamelCase										=  doc_sep
							_UpperCamelCase										=  n_docs
							_UpperCamelCase										=  max_combined_length

							_UpperCamelCase										=  dataset
							_UpperCamelCase										=  dataset_split
							_UpperCamelCase										=  index_name

							_UpperCamelCase										=  retrieval_vector_size
							_UpperCamelCase										=  retrieval_batch_size
							_UpperCamelCase										=  passages_path
							_UpperCamelCase										=  index_path
							_UpperCamelCase										=  use_dummy_dataset

							_UpperCamelCase										=  output_retrieved

							_UpperCamelCase										=  do_deduplication

							_UpperCamelCase										=  use_cache

							if self.forced_eos_token_id is None:
												_UpperCamelCase										=  getattr(self.generator    ,		'''forced_eos_token_id'''    ,		__a)



		@classmethod
		def 						UpperCAmelCase							( cls    ,		__a    ,		__a    ,		**__a)	->	Optional[int]:






							'''simple docstring'''
							return cls(question_encoder=question_encoder_config.to_dict()    ,		generator=generator_config.to_dict()    ,		**__a)




		def 						UpperCAmelCase							( self)	->	Any:






							'''simple docstring'''
							_UpperCamelCase										=  copy.deepcopy(self.__dict__)
							_UpperCamelCase										=  self.question_encoder.to_dict()
							_UpperCamelCase										=  self.generator.to_dict()
							_UpperCamelCase										=  self.__class__.model_type
							return output








"""simple docstring"""





# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import numpy as np
import torch

from ..models.clipseg import CLIPSegForImageSegmentation
from ..utils import is_vision_available, requires_backends
from .base import PipelineTool


if is_vision_available():
				from PIL import Image






class    _UpperCAmelCase(   lowerCamelCase     ):
		lowercase__      =				(
		    'This is a tool that creates a segmentation mask of an image according to a label. It cannot create an image.'
		    'It takes two arguments named `image` which should be the original image, and `label` which should be a text '
		    'describing the elements what should be identified in the segmentation mask. The tool returns the mask.'
		)
		lowercase__      =				'CIDAS/clipseg-rd64-refined'
		lowercase__      =				'image_segmenter'
		lowercase__      =				CLIPSegForImageSegmentation

		lowercase__      =				['image', 'text']
		lowercase__      =				['image']



		def __init__( self    ,		*__a    ,		**__a)	->	Any:






							'''simple docstring'''
							requires_backends(self    ,		['''vision'''])
							super().__init__(*__a    ,		**__a)



		def 						UpperCAmelCase							( self    ,		__a    ,		__a)	->	Dict:






							'''simple docstring'''
							return self.pre_processor(text=[label]    ,		images=[image]    ,		padding=__a    ,		return_tensors='''pt''')



		def 						UpperCAmelCase							( self    ,		__a)	->	Tuple:






							'''simple docstring'''
							with torch.no_grad():
												_UpperCamelCase										=  self.model(**__a).logits
							return logits




		def 						UpperCAmelCase							( self    ,		__a)	->	Any:






							'''simple docstring'''
							_UpperCamelCase										=  outputs.cpu().detach().numpy()
							_UpperCamelCase										=  0
							_UpperCamelCase										=  1
							return Image.fromarray((array * 2_55).astype(np.uinta))






