


# 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        snake_case_   (lowerCamelCase_      ):
					UpperCAmelCase__					:    str          =			'''dandelin/vilt-b32-finetuned-vqa'''
					UpperCAmelCase__					:    List[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.'''
					)
					UpperCAmelCase__					:    str          =			'''image_qa'''
					UpperCAmelCase__					:    int          =			AutoProcessor
					UpperCAmelCase__					:    List[str]          =			AutoModelForVisualQuestionAnswering

					UpperCAmelCase__					:    str          =			['''image''', '''text''']
					UpperCAmelCase__					:    int          =			['''text''']
					def __init__(      self   :List[str]			,*__snake_case   :str			,**__snake_case   :Tuple      )					->    str:
												requires_backends(self			,['vision']      )
												super().__init__(*__snake_case			,**__snake_case      )
					def  lowerCamelCase__(      self   :Tuple			,__snake_case   :"Image"			,__snake_case   :str      )					->    Tuple:
												return self.pre_processor(__snake_case			,__snake_case			,return_tensors='pt'      )
					def  lowerCamelCase__(      self   :Optional[Any]			,__snake_case   :str      )					->    Tuple:
												with torch.no_grad():
																			return self.model(**__snake_case      ).logits



					def  lowerCamelCase__(      self   :int			,__snake_case   :Union[str, Any]      )					->    str:
												a__             =     outputs.argmax(-1      ).item()
												return self.model.config.idalabel[idx]








from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


snake_case							:       Union[str, Any]     			=      logging.get_logger(__name__)

snake_case							:       str     			=      {
    '''google/mobilenet_v2_1.4_224''': '''https://huggingface.co/google/mobilenet_v2_1.4_224/resolve/main/config.json''',
    '''google/mobilenet_v2_1.0_224''': '''https://huggingface.co/google/mobilenet_v2_1.0_224/resolve/main/config.json''',
    '''google/mobilenet_v2_0.75_160''': '''https://huggingface.co/google/mobilenet_v2_0.75_160/resolve/main/config.json''',
    '''google/mobilenet_v2_0.35_96''': '''https://huggingface.co/google/mobilenet_v2_0.35_96/resolve/main/config.json''',
    # See all MobileNetV2 models at https://huggingface.co/models?filter=mobilenet_v2
}







class        snake_case_   (lowerCamelCase_      ):
					UpperCAmelCase__					:    str          =			'''mobilenet_v2'''
					def __init__(      self   :Optional[Any]			,__snake_case   :List[Any]=3			,__snake_case   :Any=2_24			,__snake_case   :Dict=1.0			,__snake_case   :str=8			,__snake_case   :Union[str, Any]=8			,__snake_case   :Optional[Any]=6			,__snake_case   :str=32			,__snake_case   :Tuple=True			,__snake_case   :Union[str, Any]=True			,__snake_case   :Any="relu6"			,__snake_case   :List[str]=True			,__snake_case   :Dict=0.8			,__snake_case   :Optional[int]=0.02			,__snake_case   :Tuple=0.0_01			,__snake_case   :Dict=2_55			,**__snake_case   :Dict			,)					->    Any:
												super().__init__(**__snake_case      )

												if depth_multiplier <= 0:
																			raise ValueError('depth_multiplier must be greater than zero.'      )

												a__             =     num_channels
												a__             =     image_size
												a__             =     depth_multiplier
												a__             =     depth_divisible_by
												a__             =     min_depth
												a__             =     expand_ratio
												a__             =     output_stride
												a__             =     first_layer_is_expansion
												a__             =     finegrained_output
												a__             =     hidden_act
												a__             =     tf_padding
												a__             =     classifier_dropout_prob
												a__             =     initializer_range
												a__             =     layer_norm_eps
												a__             =     semantic_loss_ignore_index







class        snake_case_   (lowerCamelCase_      ):
					UpperCAmelCase__					:    Tuple          =			version.parse('''1.11'''      )
					@property
					def  lowerCamelCase__(      self   :Any      )					->    Mapping[str, Mapping[int, str]]:
												return OrderedDict([('pixel_values', {0: 'batch'})]      )
					@property
					def  lowerCamelCase__(      self   :List[str]      )					->    Mapping[str, Mapping[int, str]]:
												if self.task == "image-classification":
																			return OrderedDict([('logits', {0: 'batch'})]      )
												else:
																			return OrderedDict([('last_hidden_state', {0: 'batch'}), ('pooler_output', {0: 'batch'})]      )



					@property
					def  lowerCamelCase__(      self   :Any      )					->    float:
												return 1E-4




