





'''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 re

from ..models.auto import AutoProcessor
from ..models.vision_encoder_decoder import VisionEncoderDecoderModel
from ..utils import is_vision_available
from .base import PipelineTool


if is_vision_available():
  from PIL import Image


class 					SCREAMING_SNAKE_CASE       (a__				):
     lowerCAmelCase						     =			'''naver-clova-ix/donut-base-finetuned-docvqa'''
     lowerCAmelCase						     =			(
         '''This is a tool that answers a question about an document (pdf). It takes an input named `document` which '''
         '''should be the document containing the information, as well as a `question` that is the question about the '''
         '''document. It returns a text that contains the answer to the question.'''
     )
     lowerCAmelCase						     =			'''document_qa'''
     lowerCAmelCase						     =			AutoProcessor
     lowerCAmelCase						     =			VisionEncoderDecoderModel

     lowerCAmelCase						     =			['''image''', '''text''']
     lowerCAmelCase						     =			['''text''']


     def __init__(		self		,      *_UpperCAmelCase		,      **_UpperCAmelCase):

          '''simple docstring'''






          if not is_vision_available():
               raise ValueError('Pillow must be installed to use the DocumentQuestionAnsweringTool.')

          super().__init__(*_UpperCAmelCase		,      **_UpperCAmelCase)


     def 				SCREAMING_SNAKE_CASE    (		self		,      _UpperCAmelCase		,      _UpperCAmelCase):

          '''simple docstring'''






          __A		:					Optional[int]						=			'<s_docvqa><s_question>{user_input}</s_question><s_answer>'
          __A		:					List[Any]						=			task_prompt.replace('{user_input}'		,      _UpperCAmelCase)
          __A		:					Tuple						=			self.pre_processor.tokenizer(
              _UpperCAmelCase		,      add_special_tokens=_UpperCAmelCase		,      return_tensors='pt').input_ids
          __A		:					Any						=			self.pre_processor(_UpperCAmelCase		,      return_tensors='pt').pixel_values

          return {"decoder_input_ids": decoder_input_ids, "pixel_values": pixel_values}


     def 				SCREAMING_SNAKE_CASE    (		self		,      _UpperCAmelCase):

          '''simple docstring'''






          return self.model.generate(
              inputs['pixel_values'].to(self.device)		,      decoder_input_ids=inputs['decoder_input_ids'].to(self.device)		,      max_length=self.model.decoder.config.max_position_embeddings		,      early_stopping=_UpperCAmelCase		,      pad_token_id=self.pre_processor.tokenizer.pad_token_id		,      eos_token_id=self.pre_processor.tokenizer.eos_token_id		,      use_cache=_UpperCAmelCase		,      num_beams=1		,      bad_words_ids=[[self.pre_processor.tokenizer.unk_token_id]]		,      return_dict_in_generate=_UpperCAmelCase		,      ).sequences


     def 				SCREAMING_SNAKE_CASE    (		self		,      _UpperCAmelCase):

          '''simple docstring'''






          __A		:					Optional[Any]						=			self.pre_processor.batch_decode(_UpperCAmelCase)[0]
          __A		:					Optional[Any]						=			sequence.replace(self.pre_processor.tokenizer.eos_token		,      '')
          __A		:					int						=			sequence.replace(self.pre_processor.tokenizer.pad_token		,      '')
          __A		:					Any						=			re.sub(R'<.*?>'		,      ''		,      _UpperCAmelCase		,      count=1).strip()  # remove first task start token
          __A		:					List[str]						=			self.pre_processor.tokenajson(_UpperCAmelCase)

          return sequence["answer"]

"""simple docstring"""



import argparse

import torch
from huggingface_hub import hf_hub_download

from transformers import AutoTokenizer, RobertaPreLayerNormConfig, RobertaPreLayerNormForMaskedLM
from transformers.utils import logging


logging.set_verbosity_info()
a       :						Any       		=		logging.get_logger(__name__)


def 			_UpperCamelCase						(    _A       ,   _A   )     ->	int:





    """simple docstring"""

    _UpperCAmelCase        = RobertaPreLayerNormConfig.from_pretrained(
        _A       ,   architectures=["""RobertaPreLayerNormForMaskedLM"""]   )

    # convert state_dict
    _UpperCAmelCase        = torch.load(hf_hub_download(repo_id=_A       ,   filename="""pytorch_model.bin"""   )   )
    _UpperCAmelCase        = {}
    for tensor_key, tensor_value in original_state_dict.items():
        # The transformer implementation gives the model a unique name, rather than overwiriting 'roberta'
        if tensor_key.startswith("""roberta."""   ):
            _UpperCAmelCase        = """roberta_prelayernorm.""" + tensor_key[len("""roberta."""   ) :]

        # The original implementation contains weights which are not used, remove them from the state_dict
        if tensor_key.endswith(""".self.LayerNorm.weight"""   ) or tensor_key.endswith(""".self.LayerNorm.bias"""   ):
            continue

        _UpperCAmelCase        = tensor_value

    _UpperCAmelCase        = RobertaPreLayerNormForMaskedLM.from_pretrained(
        pretrained_model_name_or_path=_A       ,   config=_A       ,   state_dict=_A   )
    model.save_pretrained(_A   )

    # convert tokenizer
    _UpperCAmelCase        = AutoTokenizer.from_pretrained(_A   )
    tokenizer.save_pretrained(_A   )


if __name__ == "__main__":
 a       :						Tuple       		=		argparse.ArgumentParser()
 # Required parameters
 parser.add_argument(
     '''--checkpoint-repo''',
     default=None,
     type=str,
     required=True,
     help='''Path the official PyTorch dump, e.g. \'andreasmadsen/efficient_mlm_m0.40\'.''',
 )
 parser.add_argument(
     '''--pytorch_dump_folder_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.'''
 )
 a       :						Union[str, Any]       		=		parser.parse_args()
 convert_roberta_prelayernorm_checkpoint_to_pytorch(args.checkpoint_repo, args.pytorch_dump_folder_path)