codingutf8 2023 the huggingface inc team 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 orglicenseslicense2 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 processor class for blip2 attributes imageprocessor tokenizer imageprocessorclass blipimageprocessor tokenizerclass autotokenizer copied from transformers models blip processingblip blipprocessor init def initself imageprocessor tokenizer tokenizer returntokentypeids false super initimageprocessor tokenizer self currentprocessor self imageprocessor copied from transformers models blip processingblip blipprocessor call def call self images imageinput none text uniontextinput pretokenizedinput listtextinput listpretokenizedinput none addspecialtokens bool true padding unionbool str paddingstrategy false truncation unionbool str truncationstrategy none maxlength optionalint none stride int 0 padtomultipleof optionalint none returnattentionmask optionalbool none returnoverflowingtokens bool false returnspecialtokensmask bool false returnoffsetsmapping bool false returntokentypeids bool false returnlength bool false verbose bool true returntensors optionalunionstr tensortype none kwargs batchencoding if images is none and text is none raise valueerroryou have to specify either images or text get only text if images is none self currentprocessor self tokenizer textencoding self tokenizer texttext addspecialtokensaddspecialtokens paddingpadding truncationtruncation maxlengthmaxlength stridestride padtomultipleofpadtomultipleof returnattentionmaskreturnattentionmask returnoverflowingtokensreturnoverflowingtokens returnspecialtokensmaskreturnspecialtokensmask returnoffsetsmappingreturnoffsetsmapping returntokentypeidsreturntokentypeids returnlengthreturnlength verboseverbose returntensorsreturntensors kwargs return textencoding add pixelvalues encodingimageprocessor self imageprocessorimages returntensorsreturntensors if text is not none textencoding self tokenizer texttext addspecialtokensaddspecialtokens paddingpadding truncationtruncation maxlengthmaxlength stridestride padtomultipleofpadtomultipleof returnattentionmaskreturnattentionmask returnoverflowingtokensreturnoverflowingtokens returnspecialtokensmaskreturnspecialtokensmask returnoffsetsmappingreturnoffsetsmapping returntokentypeidsreturntokentypeids returnlengthreturnlength verboseverbose returntensorsreturntensors kwargs else textencoding none if textencoding is not none encodingimageprocessor updatetextencoding return encodingimageprocessor copied from transformers models blip processingblip blipprocessor batchdecode with berttokenizerfastpretrainedtokenizer def batchdecodeself args kwargs return self tokenizer batchdecodeargs kwargs copied from transformers models blip processingblip blipprocessor decode with berttokenizerfastpretrainedtokenizer def decodeself args kwargs return self tokenizer decodeargs kwargs property copied from transformers models blip processingblip blipprocessor modelinputnames def modelinputnamesself tokenizerinputnames self tokenizer modelinputnames imageprocessorinputnames self imageprocessor modelinputnames return listdict fromkeystokenizerinputnames imageprocessorinputnames coding utf 8 2023 the huggingface inc team 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 processor class for blip 2 constructs a blip 2 processor which wraps a blip image processor and an opt t5 tokenizer into a single processor blipprocessor offers all the functionalities of blipimageprocessor and autotokenizer see the docstring of blipprocessor __call__ and blipprocessor decode for more information args image_processor blipimageprocessor an instance of blipimageprocessor the image processor is a required input tokenizer autotokenizer an instance of pretrainedtokenizer the tokenizer is a required input copied from transformers models blip processing_blip blipprocessor __init__ copied from transformers models blip processing_blip blipprocessor __call__ this method uses blipimageprocessor __call__ method to prepare image s for the model and berttokenizerfast __call__ to prepare text for the model please refer to the docstring of the above two methods for more information get only text add pixel_values copied from transformers models blip processing_blip blipprocessor batch_decode with berttokenizerfast pretrainedtokenizer this method forwards all its arguments to pretrainedtokenizer s pretrainedtokenizer batch_decode please refer to the docstring of this method for more information copied from transformers models blip processing_blip blipprocessor decode with berttokenizerfast pretrainedtokenizer this method forwards all its arguments to pretrainedtokenizer s pretrainedtokenizer decode please refer to the docstring of this method for more information copied from transformers models blip processing_blip blipprocessor model_input_names
from typing import List, Optional, Union

from ...image_utils import ImageInput
from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType


class Blip2Processor(ProcessorMixin):
    r

    attributes = ["image_processor", "tokenizer"]
    image_processor_class = "BlipImageProcessor"
    tokenizer_class = "AutoTokenizer"

    
    def __init__(self, image_processor, tokenizer):
        tokenizer.return_token_type_ids = False
        super().__init__(image_processor, tokenizer)
        self.current_processor = self.image_processor

    
    def __call__(
        self,
        images: ImageInput = None,
        text: Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]] = None,
        add_special_tokens: bool = True,
        padding: Union[bool, str, PaddingStrategy] = False,
        truncation: Union[bool, str, TruncationStrategy] = None,
        max_length: Optional[int] = None,
        stride: int = 0,
        pad_to_multiple_of: Optional[int] = None,
        return_attention_mask: Optional[bool] = None,
        return_overflowing_tokens: bool = False,
        return_special_tokens_mask: bool = False,
        return_offsets_mapping: bool = False,
        return_token_type_ids: bool = False,
        return_length: bool = False,
        verbose: bool = True,
        return_tensors: Optional[Union[str, TensorType]] = None,
        **kwargs,
    ) -> BatchEncoding:
        
        if images is None and text is None:
            raise ValueError("You have to specify either images or text.")

        
        if images is None:
            self.current_processor = self.tokenizer
            text_encoding = self.tokenizer(
                text=text,
                add_special_tokens=add_special_tokens,
                padding=padding,
                truncation=truncation,
                max_length=max_length,
                stride=stride,
                pad_to_multiple_of=pad_to_multiple_of,
                return_attention_mask=return_attention_mask,
                return_overflowing_tokens=return_overflowing_tokens,
                return_special_tokens_mask=return_special_tokens_mask,
                return_offsets_mapping=return_offsets_mapping,
                return_token_type_ids=return_token_type_ids,
                return_length=return_length,
                verbose=verbose,
                return_tensors=return_tensors,
                **kwargs,
            )
            return text_encoding

        
        encoding_image_processor = self.image_processor(images, return_tensors=return_tensors)

        if text is not None:
            text_encoding = self.tokenizer(
                text=text,
                add_special_tokens=add_special_tokens,
                padding=padding,
                truncation=truncation,
                max_length=max_length,
                stride=stride,
                pad_to_multiple_of=pad_to_multiple_of,
                return_attention_mask=return_attention_mask,
                return_overflowing_tokens=return_overflowing_tokens,
                return_special_tokens_mask=return_special_tokens_mask,
                return_offsets_mapping=return_offsets_mapping,
                return_token_type_ids=return_token_type_ids,
                return_length=return_length,
                verbose=verbose,
                return_tensors=return_tensors,
                **kwargs,
            )
        else:
            text_encoding = None

        if text_encoding is not None:
            encoding_image_processor.update(text_encoding)

        return encoding_image_processor

    
    def batch_decode(self, *args, **kwargs):
        
        return self.tokenizer.batch_decode(*args, **kwargs)

    
    def decode(self, *args, **kwargs):
        
        return self.tokenizer.decode(*args, **kwargs)

    @property
    
    def model_input_names(self):
        tokenizer_input_names = self.tokenizer.model_input_names
        image_processor_input_names = self.image_processor.model_input_names
        return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names))