


# 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.
from typing import TYPE_CHECKING

import torch

from ..models.auto import AutoModelForVisualQuestionAnswering, AutoProcessor
from ..utils import requires_backends
from .base import PipelineTool


if TYPE_CHECKING:
					from PIL import Image


class     __SCREAMING_SNAKE_CASE					(   __lowercase):
						_SCREAMING_SNAKE_CASE	:       List[str]   =					'''dandelin/vilt-b32-finetuned-vqa'''
						_SCREAMING_SNAKE_CASE	:       Union[str, Any]   =					(
						    '''This is a tool that answers a question about an image. It takes an input named `image` which should be the '''
						    '''image containing the information, as well as a `question` which should be the question in English. It '''
						    '''returns a text that is the answer to the question.'''
						)
						_SCREAMING_SNAKE_CASE	:       List[str]   =					'''image_qa'''
						_SCREAMING_SNAKE_CASE	:       Tuple   =					AutoProcessor
						_SCREAMING_SNAKE_CASE	:       Union[str, Any]   =					AutoModelForVisualQuestionAnswering

						_SCREAMING_SNAKE_CASE	:       Optional[Any]   =					['''image''', '''text''']
						_SCREAMING_SNAKE_CASE	:       List[str]   =					['''text''']






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






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






						def       UpperCamelCase__      (	self     ,						_UpperCamelCase     ,						_UpperCamelCase   ):






												"""simple docstring"""
												return self.pre_processor(_UpperCamelCase     ,						_UpperCamelCase     ,						return_tensors='pt'   )






						def       UpperCamelCase__      (	self     ,						_UpperCamelCase   ):






												"""simple docstring"""
												with torch.no_grad():
																		return self.model(**_UpperCamelCase   ).logits







						def       UpperCamelCase__      (	self     ,						_UpperCamelCase   ):






												"""simple docstring"""
												lowerCAmelCase__    						=						outputs.argmax(-1   ).item()
												return self.model.config.idalabel[idx]













import argparse

import torch

from transformers import BertConfig, BertForPreTraining, load_tf_weights_in_bert
from transformers.utils import logging


logging.set_verbosity_info()







def 	_UpperCamelCase   (    UpperCamelCase_       :					Dict    ,       UpperCamelCase_       :					str    ,       UpperCamelCase_       :					Optional[Any]		)  ->   Any:

						"""simple docstring"""



						lowerCAmelCase__    						=						BertConfig.from_json_file(UpperCamelCase_		)
						print(F"Building PyTorch model from configuration: {config}"		)
						lowerCAmelCase__    						=						BertForPreTraining(UpperCamelCase_		)

						# Load weights from tf checkpoint
						load_tf_weights_in_bert(UpperCamelCase_    ,       UpperCamelCase_    ,       UpperCamelCase_		)

						# Save pytorch-model
						print(F"Save PyTorch model to {pytorch_dump_path}"		)
						torch.save(model.state_dict()    ,       UpperCamelCase_		)


if __name__ == "__main__":
					__snake_case    :    Union[str, Any]         =     argparse.ArgumentParser()
					# Required parameters
					parser.add_argument(
					    """--tf_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path."""
					)
					parser.add_argument(
					    """--bert_config_file""",
					    default=None,
					    type=str,
					    required=True,
					    help=(
					        """The config json file corresponding to the pre-trained BERT model. \n"""
					        """This specifies the model architecture."""
					    ),
					)
					parser.add_argument(
					    """--pytorch_dump_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model."""
					)
					__snake_case    :    List[str]         =     parser.parse_args()
					convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.bert_config_file, args.pytorch_dump_path)





