





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

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   UpperCAmelCase      (			UpperCamelCase__							):
 __lowercase  						=							"""dandelin/vilt-b32-finetuned-vqa"""
 __lowercase  						=							(
     """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."""
 )
 __lowercase  						=							"""image_qa"""
 __lowercase  						=							AutoProcessor
 __lowercase  						=							AutoModelForVisualQuestionAnswering

 __lowercase  						=							["""image""", """text"""]
 __lowercase  						=							["""text"""]
 def __init__(							self :List[str]		,			*lowercase_ :Optional[Any]		,			**lowercase_ :Union[str, Any]				)->				Optional[Any]:
     requires_backends(self		,			["vision"]				)
     super().__init__(*lowercase_		,			**lowercase_				)
 def 	UpperCAmelCase_				(							self :Union[str, Any]		,			lowercase_ :"Image"		,			lowercase_ :str				)->				int:
     return self.pre_processor(lowercase_		,			lowercase_		,			return_tensors="pt"				)
 def 	UpperCAmelCase_				(							self :Any		,			lowercase_ :Dict				)->				Dict:
     with torch.no_grad():
         return self.model(**lowercase_				).logits



 def 	UpperCAmelCase_				(							self :Any		,			lowercase_ :List[Any]				)->				List[Any]:
     A__							=     outputs.argmax(-1				).item()
     return self.model.config.idalabel[idx]










'''simple docstring'''

from typing import Optional, Union

import torch
from torch import nn

from ...configuration_utils import ConfigMixin, register_to_config
from ...models.modeling_utils import ModelMixin






class   UpperCAmelCase      (			UpperCamelCase__     ,			UpperCamelCase__							):
 @register_to_config
 def __init__(							self :List[str]		,			lowercase_ :int = 7_68		,			)->				str:
     super().__init__()

     A__							=     nn.Parameter(torch.zeros(1		,			lowercase_				)				)
     A__							=     nn.Parameter(torch.ones(1		,			lowercase_				)				)
 def 	UpperCAmelCase_				(							self :List[Any]		,			lowercase_ :Optional[Union[str, torch.device]] = None		,			lowercase_ :Optional[torch.dtype] = None		,			)->				Tuple:
     A__							=     nn.Parameter(self.mean.to(lowercase_				).to(lowercase_				)				)
     A__							=     nn.Parameter(self.std.to(lowercase_				).to(lowercase_				)				)
     return self
 def 	UpperCAmelCase_				(							self :Optional[int]		,			lowercase_ :str				)->				Union[str, Any]:
     A__							=     (embeds - self.mean) * 1.0 / self.std
     return embeds



 def 	UpperCAmelCase_				(							self :Any		,			lowercase_ :List[Any]				)->				Tuple:
     A__							=     (embeds * self.std) + self.mean
     return embeds



