


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


UpperCAmelCase__   	=							logging.get_logger(__name__)

# General docstring
UpperCAmelCase__   	=							'''ResNetConfig'''

# Base docstring
UpperCAmelCase__   	=							'''microsoft/resnet-50'''
UpperCAmelCase__   	=							[1, 2048, 7, 7]

# Image classification docstring
UpperCAmelCase__   	=							'''microsoft/resnet-50'''
UpperCAmelCase__   	=							'''tiger cat'''

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







class       lowerCamelCase__   (       nn.Module):





     def __init__(self		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase = 3		,     UpperCAmelCase = 1		,     UpperCAmelCase = "relu"       )     ->   Any:
      super().__init__()
      _lowercase							      =nn.Convad(
          UpperCAmelCase		,     UpperCAmelCase		,     kernel_size=UpperCAmelCase		,     stride=UpperCAmelCase		,     padding=kernel_size // 2		,     bias=UpperCAmelCase       )
      _lowercase							      =nn.BatchNormad(UpperCAmelCase       )
      _lowercase							      =ACTaFN[activation] if activation is not None else nn.Identity()





     def      __A					(self		,     UpperCAmelCase       )     ->   Tensor:
      _lowercase							      =self.convolution(UpperCAmelCase       )
      _lowercase							      =self.normalization(UpperCAmelCase       )
      _lowercase							      =self.activation(UpperCAmelCase       )
      return hidden_state







class       lowerCamelCase__   (       nn.Module):





     def __init__(self		,     UpperCAmelCase       )     ->   str:
      super().__init__()
      _lowercase							      =ResNetConvLayer(
          config.num_channels		,     config.embedding_size		,     kernel_size=7		,     stride=2		,     activation=config.hidden_act       )
      _lowercase							      =nn.MaxPoolad(kernel_size=3		,     stride=2		,     padding=1       )
      _lowercase							      =config.num_channels





     def      __A					(self		,     UpperCAmelCase       )     ->   Tensor:
      _lowercase							      =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.'''       )
      _lowercase							      =self.embedder(UpperCAmelCase       )
      _lowercase							      =self.pooler(UpperCAmelCase       )
      return embedding







class       lowerCamelCase__   (       nn.Module):





     def __init__(self		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase = 2       )     ->   Dict:
      super().__init__()
      _lowercase							      =nn.Convad(UpperCAmelCase		,     UpperCAmelCase		,     kernel_size=1		,     stride=UpperCAmelCase		,     bias=UpperCAmelCase       )
      _lowercase							      =nn.BatchNormad(UpperCAmelCase       )





     def      __A					(self		,     UpperCAmelCase       )     ->   Tensor:
      _lowercase							      =self.convolution(UpperCAmelCase       )
      _lowercase							      =self.normalization(UpperCAmelCase       )
      return hidden_state







class       lowerCamelCase__   (       nn.Module):





     def __init__(self		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase = 1		,     UpperCAmelCase = "relu"       )     ->   Optional[Any]:
      super().__init__()
      _lowercase							      =in_channels != out_channels or stride != 1
      _lowercase							      =(
          ResNetShortCut(UpperCAmelCase		,     UpperCAmelCase		,     stride=UpperCAmelCase       ) if should_apply_shortcut else nn.Identity()
      )
      _lowercase							      =nn.Sequential(
          ResNetConvLayer(UpperCAmelCase		,     UpperCAmelCase		,     stride=UpperCAmelCase       )		,     ResNetConvLayer(UpperCAmelCase		,     UpperCAmelCase		,     activation=UpperCAmelCase       )		,     )
      _lowercase							      =ACTaFN[activation]





     def      __A					(self		,     UpperCAmelCase       )     ->   List[str]:
      _lowercase							      =hidden_state
      _lowercase							      =self.layer(UpperCAmelCase       )
      _lowercase							      =self.shortcut(UpperCAmelCase       )
      hidden_state += residual
      _lowercase							      =self.activation(UpperCAmelCase       )
      return hidden_state







class       lowerCamelCase__   (       nn.Module):





     def __init__(self		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase = 1		,     UpperCAmelCase = "relu"		,     UpperCAmelCase = 4       )     ->   Any:
      super().__init__()
      _lowercase							      =in_channels != out_channels or stride != 1
      _lowercase							      =out_channels // reduction
      _lowercase							      =(
          ResNetShortCut(UpperCAmelCase		,     UpperCAmelCase		,     stride=UpperCAmelCase       ) if should_apply_shortcut else nn.Identity()
      )
      _lowercase							      =nn.Sequential(
          ResNetConvLayer(UpperCAmelCase		,     UpperCAmelCase		,     kernel_size=1       )		,     ResNetConvLayer(UpperCAmelCase		,     UpperCAmelCase		,     stride=UpperCAmelCase       )		,     ResNetConvLayer(UpperCAmelCase		,     UpperCAmelCase		,     kernel_size=1		,     activation=UpperCAmelCase       )		,     )
      _lowercase							      =ACTaFN[activation]





     def      __A					(self		,     UpperCAmelCase       )     ->   Dict:
      _lowercase							      =hidden_state
      _lowercase							      =self.layer(UpperCAmelCase       )
      _lowercase							      =self.shortcut(UpperCAmelCase       )
      hidden_state += residual
      _lowercase							      =self.activation(UpperCAmelCase       )
      return hidden_state







class       lowerCamelCase__   (       nn.Module):





     def __init__(self		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase = 2		,     UpperCAmelCase = 2		,     )     ->   List[Any]:
      super().__init__()

      _lowercase							      =ResNetBottleNeckLayer if config.layer_type == '''bottleneck''' else ResNetBasicLayer

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





     def      __A					(self		,     UpperCAmelCase       )     ->   Tensor:
      _lowercase							      =input
      for layer in self.layers:
       _lowercase							      =layer(UpperCAmelCase       )
      return hidden_state







class       lowerCamelCase__   (       nn.Module):





     def __init__(self		,     UpperCAmelCase       )     ->   List[str]:
      super().__init__()
      _lowercase							      =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(
              UpperCAmelCase		,     config.embedding_size		,     config.hidden_sizes[0]		,     stride=2 if config.downsample_in_first_stage else 1		,     depth=config.depths[0]		,     )       )
      _lowercase							      =zip(config.hidden_sizes		,     config.hidden_sizes[1:]       )
      for (in_channels, out_channels), depth in zip(UpperCAmelCase		,     config.depths[1:]       ):
       self.stages.append(ResNetStage(UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     depth=UpperCAmelCase       )       )





     def      __A					(self		,     UpperCAmelCase		,     UpperCAmelCase = False		,     UpperCAmelCase = True       )     ->   BaseModelOutputWithNoAttention:
      _lowercase							      =() if output_hidden_states else None

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

       _lowercase							      =stage_module(UpperCAmelCase       )

      if output_hidden_states:
       _lowercase							      =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=UpperCAmelCase		,     hidden_states=UpperCAmelCase		,     )







class       lowerCamelCase__   (       lowerCAmelCase):
     SCREAMING_SNAKE_CASE__      			=			ResNetConfig
     SCREAMING_SNAKE_CASE__      			=			'''resnet'''
     SCREAMING_SNAKE_CASE__      			=			'''pixel_values'''
     SCREAMING_SNAKE_CASE__      			=			True





     def      __A					(self		,     UpperCAmelCase       )     ->   Union[str, Any]:
      if isinstance(UpperCAmelCase		,     nn.Convad       ):
       nn.init.kaiming_normal_(module.weight		,     mode='''fan_out'''		,     nonlinearity='''relu'''       )
      elif isinstance(UpperCAmelCase		,     (nn.BatchNormad, nn.GroupNorm)       ):
       nn.init.constant_(module.weight		,     1       )
       nn.init.constant_(module.bias		,     0       )





     def      __A					(self		,     UpperCAmelCase		,     UpperCAmelCase=False       )     ->   Dict:
      if isinstance(UpperCAmelCase		,     UpperCAmelCase       ):
       _lowercase							      =value



UpperCAmelCase__   	=							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.
'''

UpperCAmelCase__   	=							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.'''   ,							lowerCAmelCase   ,							)
class       lowerCamelCase__   (       lowerCAmelCase):





     def __init__(self		,     UpperCAmelCase       )     ->   str:
      super().__init__(UpperCAmelCase       )
      _lowercase							      =config
      _lowercase							      =ResNetEmbeddings(UpperCAmelCase       )
      _lowercase							      =ResNetEncoder(UpperCAmelCase       )
      _lowercase							      =nn.AdaptiveAvgPoolad((1, 1)       )
      # Initialize weights and apply final processing
      self.post_init()





     @add_start_docstrings_to_model_forward(UpperCAmelCase       )
     @add_code_sample_docstrings(
         checkpoint=_CHECKPOINT_FOR_DOC		,     output_type=UpperCAmelCase		,     config_class=_CONFIG_FOR_DOC		,     modality='''vision'''		,     expected_output=_EXPECTED_OUTPUT_SHAPE		,     )
     def      __A					(self		,     UpperCAmelCase		,     UpperCAmelCase = None		,     UpperCAmelCase = None       )     ->   BaseModelOutputWithPoolingAndNoAttention:
      _lowercase							      =(
          output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
      )
      _lowercase							      =return_dict if return_dict is not None else self.config.use_return_dict

      _lowercase							      =self.embedder(UpperCAmelCase       )

      _lowercase							      =self.encoder(
          UpperCAmelCase		,     output_hidden_states=UpperCAmelCase		,     return_dict=UpperCAmelCase       )

      _lowercase							      =encoder_outputs[0]

      _lowercase							      =self.pooler(UpperCAmelCase       )

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

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







@add_start_docstrings(
    '''
    ResNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for
    ImageNet.
    '''   ,							lowerCAmelCase   ,							)
class       lowerCamelCase__   (       lowerCAmelCase):





     def __init__(self		,     UpperCAmelCase       )     ->   int:
      super().__init__(UpperCAmelCase       )
      _lowercase							      =config.num_labels
      _lowercase							      =ResNetModel(UpperCAmelCase       )
      # classification head
      _lowercase							      =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(UpperCAmelCase       )
     @add_code_sample_docstrings(
         checkpoint=_IMAGE_CLASS_CHECKPOINT		,     output_type=UpperCAmelCase		,     config_class=_CONFIG_FOR_DOC		,     expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT		,     )
     def      __A					(self		,     UpperCAmelCase = None		,     UpperCAmelCase = None		,     UpperCAmelCase = None		,     UpperCAmelCase = None		,     )     ->   ImageClassifierOutputWithNoAttention:
      _lowercase							      =return_dict if return_dict is not None else self.config.use_return_dict

      _lowercase							      =self.resnet(UpperCAmelCase		,     output_hidden_states=UpperCAmelCase		,     return_dict=UpperCAmelCase       )

      _lowercase							      =outputs.pooler_output if return_dict else outputs[1]

      _lowercase							      =self.classifier(UpperCAmelCase       )

      _lowercase							      =None

      if labels is not None:
       if self.config.problem_type is None:
        if self.num_labels == 1:
         _lowercase							      ='''regression'''
        elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
         _lowercase							      ='''single_label_classification'''
        else:
         _lowercase							      ='''multi_label_classification'''
       if self.config.problem_type == "regression":
        _lowercase							      =MSELoss()
        if self.num_labels == 1:
         _lowercase							      =loss_fct(logits.squeeze()		,     labels.squeeze()       )
        else:
         _lowercase							      =loss_fct(UpperCAmelCase		,     UpperCAmelCase       )
       elif self.config.problem_type == "single_label_classification":
        _lowercase							      =CrossEntropyLoss()
        _lowercase							      =loss_fct(logits.view(-1		,     self.num_labels       )		,     labels.view(-1       )       )
       elif self.config.problem_type == "multi_label_classification":
        _lowercase							      =BCEWithLogitsLoss()
        _lowercase							      =loss_fct(UpperCAmelCase		,     UpperCAmelCase       )

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

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







@add_start_docstrings(
    '''
    ResNet backbone, to be used with frameworks like DETR and MaskFormer.
    '''   ,							lowerCAmelCase   ,							)
class       lowerCamelCase__   (       lowerCAmelCase   ,							lowerCAmelCase):





     def __init__(self		,     UpperCAmelCase       )     ->   Tuple:
      super().__init__(UpperCAmelCase       )
      super()._init_backbone(UpperCAmelCase       )

      _lowercase							      =[config.embedding_size] + config.hidden_sizes
      _lowercase							      =ResNetEmbeddings(UpperCAmelCase       )
      _lowercase							      =ResNetEncoder(UpperCAmelCase       )

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





     @add_start_docstrings_to_model_forward(UpperCAmelCase       )
     @replace_return_docstrings(output_type=UpperCAmelCase		,     config_class=_CONFIG_FOR_DOC       )
     def      __A					(self		,     UpperCAmelCase		,     UpperCAmelCase = None		,     UpperCAmelCase = None       )     ->   BackboneOutput:
      _lowercase							      =return_dict if return_dict is not None else self.config.use_return_dict
      _lowercase							      =(
          output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
      )

      _lowercase							      =self.embedder(UpperCAmelCase       )

      _lowercase							      =self.encoder(UpperCAmelCase		,     output_hidden_states=UpperCAmelCase		,     return_dict=UpperCAmelCase       )

      _lowercase							      =outputs.hidden_states

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

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

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



from __future__ import annotations

import collections
import pprint
from pathlib import Path





def     _a					(						lowerCamelCase							):
 return "".join(sorted(lowerCamelCase							)							)





def     _a					(						lowerCamelCase							):
 return word_by_signature[signature(lowerCamelCase							)]


_lowerCamelCase					   =Path(__file__).parent.joinpath("""words.txt""").read_text(encoding="""utf-8""")
_lowerCamelCase					   =sorted({word.strip().lower() for word in data.splitlines()})

_lowerCamelCase					   =collections.defaultdict(list)
for word in word_list:
      word_by_signature[signature(word)].append(word)

if __name__ == "__main__":
      _lowerCamelCase					   ={word: anagram(word) for word in word_list if len(anagram(word)) > 1}

      with open("""anagrams.txt""", """w""") as file:
            file.write("""all_anagrams = \n """)
            file.write(pprint.pformat(all_anagrams))




