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

from ..models.auto import AutoModelForVisionaSeq
from ..utils import requires_backends
from .base import PipelineTool


if TYPE_CHECKING:
 from PIL import Image

class 			UpperCAmelCase__    (							A			):
    lowerCAmelCase_					     =		'Salesforce/blip-image-captioning-base'
    lowerCAmelCase_					     =		(
        'This is a tool that generates a description of an image. It takes an input named `image` which should be the '
        'image to caption, and returns a text that contains the description in English.'
    )
    lowerCAmelCase_					     =		'image_captioner'
    lowerCAmelCase_					     =		AutoModelForVisionaSeq

    lowerCAmelCase_					     =		['image']
    lowerCAmelCase_					     =		['text']



    def __init__(						self   :							Optional[int],*__A   :							List[str],**__A   :							Optional[int]  ):
          requires_backends(self,["vision"]  )
          super().__init__(*__A,**__A  )



    def 	lowerCamelCase_	(						self   :							str,__A   :							"Image"  ):
          return self.pre_processor(images=__A,return_tensors="pt"  )



    def 	lowerCamelCase_	(						self   :							Any,__A   :							Dict  ):
          return self.model.generate(**__A  )



    def 	lowerCamelCase_	(						self   :							int,__A   :							List[str]  ):
          return self.pre_processor.batch_decode(__A,skip_special_tokens=__A  )[0].strip()





import argparse

import torch

from transformers import FunnelBaseModel, FunnelConfig, FunnelModel, load_tf_weights_in_funnel
from transformers.utils import logging


logging.set_verbosity_info()

def lowercase    (  SCREAMING_SNAKE_CASE       ,    SCREAMING_SNAKE_CASE       ,    SCREAMING_SNAKE_CASE       ,    SCREAMING_SNAKE_CASE )			->							Union[str, Any]:


			'''simple docstring'''







			SCREAMING_SNAKE_CASE_								=						FunnelConfig.from_json_file(SCREAMING_SNAKE_CASE )
			print(F'Building PyTorch model from configuration: {config}' )
			SCREAMING_SNAKE_CASE_								=						FunnelBaseModel(SCREAMING_SNAKE_CASE ) if base_model else FunnelModel(SCREAMING_SNAKE_CASE )

			# Load weights from tf checkpoint
			load_tf_weights_in_funnel(SCREAMING_SNAKE_CASE       ,    SCREAMING_SNAKE_CASE       ,    SCREAMING_SNAKE_CASE )

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


if __name__ == "__main__":
				SCREAMING_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(
				    "--config_file",
				    default=None,
				    type=str,
				    required=True,
				    help="The config json file corresponding to the pre-trained model. \nThis specifies the model architecture.",
				)
				parser.add_argument(
				    "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
				)
				parser.add_argument(
				    "--base_model", action="store_true", help="Whether you want just the base model (no decoder) or not."
				)
				SCREAMING_SNAKE_CASE__     :     List[Any]		    =       parser.parse_args()
				convert_tf_checkpoint_to_pytorch(
				    args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path, args.base_model
				)
