






from typing import Optional

import torch
import torch.utils.checkpoint
from torch import Tensor, nn
from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss

from ...activations import ACTaFN
from ...modeling_outputs import (
    BackboneOutput,
    BaseModelOutputWithNoAttention,
    BaseModelOutputWithPoolingAndNoAttention,
    ImageClassifierOutputWithNoAttention,
)
from ...modeling_utils import PreTrainedModel
from ...utils import (
    add_code_sample_docstrings,
    add_start_docstrings,
    add_start_docstrings_to_model_forward,
    logging,
    replace_return_docstrings,
)
from ...utils.backbone_utils import BackboneMixin
from .configuration_resnet import ResNetConfig


lowerCamelCase__							=     logging.get_logger(__name__)

# General docstring
lowerCamelCase__							=     """ResNetConfig"""

# Base docstring
lowerCamelCase__							=     """microsoft/resnet-50"""
lowerCamelCase__							=     [1, 2048, 7, 7]

# Image classification docstring
lowerCamelCase__							=     """microsoft/resnet-50"""
lowerCamelCase__							=     """tiger cat"""

lowerCamelCase__							=     [
    """microsoft/resnet-50""",
    # See all resnet models at https://huggingface.co/models?filter=resnet
]




class 			snake_case__   (							nn.Module):

       '''simple docstring'''



       def __init__(							self			,						a__			,						a__			,						a__ = 3			,						a__ = 1			,						a__ = "relu"    ) ->      Optional[Any]:






            '''simple docstring'''





            super().__init__()
            __snake_case			:Optional[Any]          =						nn.Convad(
                a__			,						a__			,						kernel_size=a__			,						stride=a__			,						padding=kernel_size // 2			,						bias=a__    )
            __snake_case			:List[str]          =						nn.BatchNormad(a__    )
            __snake_case			:Union[str, Any]          =						ACTaFN[activation] if activation is not None else nn.Identity()



       def 					__lowercase						(							self			,						a__    ) ->      Tensor:






            '''simple docstring'''





            __snake_case			:List[str]          =						self.convolution(a__    )
            __snake_case			:Union[str, Any]          =						self.normalization(a__    )
            __snake_case			:Dict          =						self.activation(a__    )
            return hidden_state




class 			snake_case__   (							nn.Module):

       '''simple docstring'''



       def __init__(							self			,						a__    ) ->      Union[str, Any]:






            '''simple docstring'''





            super().__init__()
            __snake_case			:Any          =						ResNetConvLayer(
                config.num_channels			,						config.embedding_size			,						kernel_size=7			,						stride=2			,						activation=config.hidden_act    )
            __snake_case			:List[str]          =						nn.MaxPoolad(kernel_size=3			,						stride=2			,						padding=1    )
            __snake_case			:List[Any]          =						config.num_channels



       def 					__lowercase						(							self			,						a__    ) ->      Tensor:






            '''simple docstring'''





            __snake_case			:Tuple          =						pixel_values.shape[1]
            if num_channels != self.num_channels:
                 raise ValueError(
                     """Make sure that the channel dimension of the pixel values match with the one set in the configuration."""    )
            __snake_case			:List[str]          =						self.embedder(a__    )
            __snake_case			:Dict          =						self.pooler(a__    )
            return embedding




class 			snake_case__   (							nn.Module):

       '''simple docstring'''



       def __init__(							self			,						a__			,						a__			,						a__ = 2    ) ->      Dict:






            '''simple docstring'''





            super().__init__()
            __snake_case			:Any          =						nn.Convad(a__			,						a__			,						kernel_size=1			,						stride=a__			,						bias=a__    )
            __snake_case			:Dict          =						nn.BatchNormad(a__    )



       def 					__lowercase						(							self			,						a__    ) ->      Tensor:






            '''simple docstring'''





            __snake_case			:List[str]          =						self.convolution(a__    )
            __snake_case			:Union[str, Any]          =						self.normalization(a__    )
            return hidden_state




class 			snake_case__   (							nn.Module):

       '''simple docstring'''



       def __init__(							self			,						a__			,						a__			,						a__ = 1			,						a__ = "relu"    ) ->      str:






            '''simple docstring'''





            super().__init__()
            __snake_case			:List[str]          =						in_channels != out_channels or stride != 1
            __snake_case			:Union[str, Any]          =						(
                ResNetShortCut(a__			,						a__			,						stride=a__    ) if should_apply_shortcut else nn.Identity()
            )
            __snake_case			:Tuple          =						nn.Sequential(
                ResNetConvLayer(a__			,						a__			,						stride=a__    )			,						ResNetConvLayer(a__			,						a__			,						activation=a__    )			,						)
            __snake_case			:Union[str, Any]          =						ACTaFN[activation]



       def 					__lowercase						(							self			,						a__    ) ->      Any:






            '''simple docstring'''





            __snake_case			:List[str]          =						hidden_state
            __snake_case			:List[str]          =						self.layer(a__    )
            __snake_case			:Tuple          =						self.shortcut(a__    )
            hidden_state += residual
            __snake_case			:Any          =						self.activation(a__    )
            return hidden_state




class 			snake_case__   (							nn.Module):

       '''simple docstring'''



       def __init__(							self			,						a__			,						a__			,						a__ = 1			,						a__ = "relu"			,						a__ = 4    ) ->      List[str]:






            '''simple docstring'''





            super().__init__()
            __snake_case			:List[Any]          =						in_channels != out_channels or stride != 1
            __snake_case			:str          =						out_channels // reduction
            __snake_case			:Dict          =						(
                ResNetShortCut(a__			,						a__			,						stride=a__    ) if should_apply_shortcut else nn.Identity()
            )
            __snake_case			:Union[str, Any]          =						nn.Sequential(
                ResNetConvLayer(a__			,						a__			,						kernel_size=1    )			,						ResNetConvLayer(a__			,						a__			,						stride=a__    )			,						ResNetConvLayer(a__			,						a__			,						kernel_size=1			,						activation=a__    )			,						)
            __snake_case			:Optional[Any]          =						ACTaFN[activation]



       def 					__lowercase						(							self			,						a__    ) ->      Any:






            '''simple docstring'''





            __snake_case			:Union[str, Any]          =						hidden_state
            __snake_case			:int          =						self.layer(a__    )
            __snake_case			:Any          =						self.shortcut(a__    )
            hidden_state += residual
            __snake_case			:str          =						self.activation(a__    )
            return hidden_state




class 			snake_case__   (							nn.Module):

       '''simple docstring'''



       def __init__(							self			,						a__			,						a__			,						a__			,						a__ = 2			,						a__ = 2			,						) ->      Any:






            '''simple docstring'''





            super().__init__()

            __snake_case			:Dict          =						ResNetBottleNeckLayer if config.layer_type == """bottleneck""" else ResNetBasicLayer

            __snake_case			:int          =						nn.Sequential(
                # downsampling is done in the first layer with stride of 2
                layer(a__			,						a__			,						stride=a__			,						activation=config.hidden_act    )			,						*[layer(a__			,						a__			,						activation=config.hidden_act    ) for _ in range(depth - 1    )]			,						)



       def 					__lowercase						(							self			,						a__    ) ->      Tensor:






            '''simple docstring'''





            __snake_case			:Dict          =						input
            for layer in self.layers:
                 __snake_case			:Tuple          =						layer(a__    )
            return hidden_state




class 			snake_case__   (							nn.Module):

       '''simple docstring'''



       def __init__(							self			,						a__    ) ->      Dict:






            '''simple docstring'''





            super().__init__()
            __snake_case			:int          =						nn.ModuleList([]    )
            # based on `downsample_in_first_stage` the first layer of the first stage may or may not downsample the input
            self.stages.append(
                ResNetStage(
                    a__			,						config.embedding_size			,						config.hidden_sizes[0]			,						stride=2 if config.downsample_in_first_stage else 1			,						depth=config.depths[0]			,						)    )
            __snake_case			:Optional[Any]          =						zip(config.hidden_sizes			,						config.hidden_sizes[1:]    )
            for (in_channels, out_channels), depth in zip(a__			,						config.depths[1:]    ):
                 self.stages.append(ResNetStage(a__			,						a__			,						a__			,						depth=a__    )    )



       def 					__lowercase						(							self			,						a__			,						a__ = False			,						a__ = True    ) ->      BaseModelOutputWithNoAttention:






            '''simple docstring'''





            __snake_case			:Optional[int]          =						() if output_hidden_states else None

            for stage_module in self.stages:
                 if output_hidden_states:
                      __snake_case			:int          =						hidden_states + (hidden_state,)

                 __snake_case			:List[str]          =						stage_module(a__    )

            if output_hidden_states:
                 __snake_case			:Tuple          =						hidden_states + (hidden_state,)

            if not return_dict:
                 return tuple(v for v in [hidden_state, hidden_states] if v is not None    )

            return BaseModelOutputWithNoAttention(
                last_hidden_state=a__			,						hidden_states=a__			,						)




class 			snake_case__   (							lowercase_):

       '''simple docstring'''
       lowerCamelCase							:				List[str] 				= ResNetConfig
       lowerCamelCase							:				Tuple 				= "resnet"
       lowerCamelCase							:				List[str] 				= "pixel_values"
       lowerCamelCase							:				Optional[Any] 				= True



       def 					__lowercase						(							self			,						a__    ) ->      List[Any]:






            '''simple docstring'''





            if isinstance(a__			,						nn.Convad    ):
                 nn.init.kaiming_normal_(module.weight			,						mode="""fan_out"""			,						nonlinearity="""relu"""    )
            elif isinstance(a__			,						(nn.BatchNormad, nn.GroupNorm)    ):
                 nn.init.constant_(module.weight			,						1    )
                 nn.init.constant_(module.bias			,						0    )



       def 					__lowercase						(							self			,						a__			,						a__=False    ) ->      List[Any]:






            '''simple docstring'''





            if isinstance(a__			,						a__    ):
                 __snake_case			:Dict          =						value
lowerCamelCase__							=     R"""
    This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. Use it
    as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and
    behavior.

    Parameters:
        config ([`ResNetConfig`]): Model configuration class with all the parameters of the model.
            Initializing with a config file does not load the weights associated with the model, only the
            configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.
"""

lowerCamelCase__							=     R"""
    Args:
        pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See
            [`ConvNextImageProcessor.__call__`] for details.

        output_hidden_states (`bool`, *optional*):
            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
            more detail.
        return_dict (`bool`, *optional*):
            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
"""




@add_start_docstrings(
    "The bare ResNet model outputting raw features without any specific head on top."	,    lowercase_	,    )
class 			snake_case__   (							lowercase_):

       '''simple docstring'''



       def __init__(							self			,						a__    ) ->      Optional[Any]:






            '''simple docstring'''





            super().__init__(a__    )
            __snake_case			:Any          =						config
            __snake_case			:Dict          =						ResNetEmbeddings(a__    )
            __snake_case			:Optional[Any]          =						ResNetEncoder(a__    )
            __snake_case			:Optional[int]          =						nn.AdaptiveAvgPoolad((1, 1)    )
            # Initialize weights and apply final processing
            self.post_init()



       @add_start_docstrings_to_model_forward(a__    )
       @add_code_sample_docstrings(
           checkpoint=_CHECKPOINT_FOR_DOC			,						output_type=a__			,						config_class=_CONFIG_FOR_DOC			,						modality="""vision"""			,						expected_output=_EXPECTED_OUTPUT_SHAPE			,						)
       def 					__lowercase						(							self			,						a__			,						a__ = None			,						a__ = None    ) ->      BaseModelOutputWithPoolingAndNoAttention:






            '''simple docstring'''





            __snake_case			:str          =						(
                output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
            )
            __snake_case			:Dict          =						return_dict if return_dict is not None else self.config.use_return_dict

            __snake_case			:Any          =						self.embedder(a__    )

            __snake_case			:Dict          =						self.encoder(
                a__			,						output_hidden_states=a__			,						return_dict=a__    )

            __snake_case			:Any          =						encoder_outputs[0]

            __snake_case			:str          =						self.pooler(a__    )

            if not return_dict:
                 return (last_hidden_state, pooled_output) + encoder_outputs[1:]

            return BaseModelOutputWithPoolingAndNoAttention(
                last_hidden_state=a__			,						pooler_output=a__			,						hidden_states=encoder_outputs.hidden_states			,						)




@add_start_docstrings(
    "\n    ResNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for\n    ImageNet.\n    "	,    lowercase_	,    )
class 			snake_case__   (							lowercase_):

       '''simple docstring'''



       def __init__(							self			,						a__    ) ->      Union[str, Any]:






            '''simple docstring'''





            super().__init__(a__    )
            __snake_case			:Tuple          =						config.num_labels
            __snake_case			:Dict          =						ResNetModel(a__    )
            # classification head
            __snake_case			:Any          =						nn.Sequential(
                nn.Flatten()			,						nn.Linear(config.hidden_sizes[-1]			,						config.num_labels    ) if config.num_labels > 0 else nn.Identity()			,						)
            # initialize weights and apply final processing
            self.post_init()



       @add_start_docstrings_to_model_forward(a__    )
       @add_code_sample_docstrings(
           checkpoint=_IMAGE_CLASS_CHECKPOINT			,						output_type=a__			,						config_class=_CONFIG_FOR_DOC			,						expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT			,						)
       def 					__lowercase						(							self			,						a__ = None			,						a__ = None			,						a__ = None			,						a__ = None			,						) ->      ImageClassifierOutputWithNoAttention:






            '''simple docstring'''





            __snake_case			:str          =						return_dict if return_dict is not None else self.config.use_return_dict

            __snake_case			:int          =						self.resnet(a__			,						output_hidden_states=a__			,						return_dict=a__    )

            __snake_case			:str          =						outputs.pooler_output if return_dict else outputs[1]

            __snake_case			:str          =						self.classifier(a__    )

            __snake_case			:Optional[Any]          =						None

            if labels is not None:
                 if self.config.problem_type is None:
                      if self.num_labels == 1:
                           __snake_case			:List[str]          =						"""regression"""
                      elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
                           __snake_case			:str          =						"""single_label_classification"""
                      else:
                           __snake_case			:Any          =						"""multi_label_classification"""
                 if self.config.problem_type == "regression":
                      __snake_case			:Optional[Any]          =						MSELoss()
                      if self.num_labels == 1:
                           __snake_case			:Any          =						loss_fct(logits.squeeze()			,						labels.squeeze()    )
                      else:
                           __snake_case			:Any          =						loss_fct(a__			,						a__    )
                 elif self.config.problem_type == "single_label_classification":
                      __snake_case			:Optional[int]          =						CrossEntropyLoss()
                      __snake_case			:str          =						loss_fct(logits.view(-1			,						self.num_labels    )			,						labels.view(-1    )    )
                 elif self.config.problem_type == "multi_label_classification":
                      __snake_case			:Optional[int]          =						BCEWithLogitsLoss()
                      __snake_case			:int          =						loss_fct(a__			,						a__    )

            if not return_dict:
                 __snake_case			:Union[str, Any]          =						(logits,) + outputs[2:]
                 return (loss,) + output if loss is not None else output

            return ImageClassifierOutputWithNoAttention(loss=a__			,						logits=a__			,						hidden_states=outputs.hidden_states    )




@add_start_docstrings(
    "\n    ResNet backbone, to be used with frameworks like DETR and MaskFormer.\n    "	,    lowercase_	,    )
class 			snake_case__   (							lowercase_	,    lowercase_):

       '''simple docstring'''



       def __init__(							self			,						a__    ) ->      Union[str, Any]:






            '''simple docstring'''





            super().__init__(a__    )
            super()._init_backbone(a__    )

            __snake_case			:int          =						[config.embedding_size] + config.hidden_sizes
            __snake_case			:List[Any]          =						ResNetEmbeddings(a__    )
            __snake_case			:List[str]          =						ResNetEncoder(a__    )

            # initialize weights and apply final processing
            self.post_init()



       @add_start_docstrings_to_model_forward(a__    )
       @replace_return_docstrings(output_type=a__			,						config_class=_CONFIG_FOR_DOC    )
       def 					__lowercase						(							self			,						a__			,						a__ = None			,						a__ = None    ) ->      BackboneOutput:






            '''simple docstring'''





            __snake_case			:Dict          =						return_dict if return_dict is not None else self.config.use_return_dict
            __snake_case			:List[Any]          =						(
                output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
            )

            __snake_case			:Union[str, Any]          =						self.embedder(a__    )

            __snake_case			:int          =						self.encoder(a__			,						output_hidden_states=a__			,						return_dict=a__    )

            __snake_case			:List[Any]          =						outputs.hidden_states

            __snake_case			:int          =						()
            for idx, stage in enumerate(self.stage_names    ):
                 if stage in self.out_features:
                      feature_maps += (hidden_states[idx],)

            if not return_dict:
                 __snake_case			:str          =						(feature_maps,)
                 if output_hidden_states:
                      output += (outputs.hidden_states,)
                 return output

            return BackboneOutput(
                feature_maps=a__			,						hidden_states=outputs.hidden_states if output_hidden_states else None			,						attentions=a__			,						)










import unittest

from transformers import load_tool

from .test_tools_common import ToolTesterMixin


lowerCamelCase__							=     """
Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf originally as a company that developed a chatbot app targeted at teenagers.[2] After open-sourcing the model behind the chatbot, the company pivoted to focus on being a platform for machine learning.

In March 2021, Hugging Face raised $40 million in a Series B funding round.[3]

On April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model.[4] In 2022, the workshop concluded with the announcement of BLOOM, a multilingual large language model with 176 billion parameters.[5]
"""




class 			snake_case__   (							unittest.TestCase	,    lowercase_):

       '''simple docstring'''



       def 					__lowercase						(							self    ) ->      List[str]:






            '''simple docstring'''





            __snake_case			:int          =						load_tool("""text-question-answering"""    )
            self.tool.setup()
            __snake_case			:Tuple          =						load_tool("""text-question-answering"""			,						remote=a__    )



       def 					__lowercase						(							self    ) ->      Any:






            '''simple docstring'''





            __snake_case			:List[str]          =						self.tool(a__			,						"""What did Hugging Face do in April 2021?"""    )
            self.assertEqual(a__			,						"""launched the BigScience Research Workshop"""    )



       def 					__lowercase						(							self    ) ->      Any:






            '''simple docstring'''





            __snake_case			:List[str]          =						self.remote_tool(a__			,						"""What did Hugging Face do in April 2021?"""    )
            self.assertEqual(a__			,						"""launched the BigScience Research Workshop"""    )



       def 					__lowercase						(							self    ) ->      Dict:






            '''simple docstring'''





            __snake_case			:Optional[int]          =						self.tool(text=a__			,						question="""What did Hugging Face do in April 2021?"""    )
            self.assertEqual(a__			,						"""launched the BigScience Research Workshop"""    )



       def 					__lowercase						(							self    ) ->      Tuple:






            '''simple docstring'''





            __snake_case			:List[str]          =						self.remote_tool(text=a__			,						question="""What did Hugging Face do in April 2021?"""    )
            self.assertEqual(a__			,						"""launched the BigScience Research Workshop"""    )


