



"""simple docstring"""
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


SCREAMING_SNAKE_CASE_				= logging.get_logger(__name__)

# General docstring
SCREAMING_SNAKE_CASE_				= """ResNetConfig"""

# Base docstring
SCREAMING_SNAKE_CASE_				= """microsoft/resnet-50"""
SCREAMING_SNAKE_CASE_				= [1, 20_48, 7, 7]

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

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




class 			snake_case_						(						nn.Module				):






							def __init__(   self			,     a_			,     a_			,     a_ = 3			,     a_ = 1			,     a_ = "relu"      ):
									super().__init__()
									a_     :      Dict 						=     nn.Convad(
									    __lowerCAmelCase			,     __lowerCAmelCase			,     kernel_size=__lowerCAmelCase			,     stride=__lowerCAmelCase			,     padding=kernel_size // 2			,     bias=__lowerCAmelCase      )
									a_     :      Optional[Any] 						=     nn.BatchNormad(__lowerCAmelCase      )
									a_     :      str 						=     ACTaFN[activation] if activation is not None else nn.Identity()






							def snake_case_  (   self			,     a_      ):
									a_     :      List[str] 						=     self.convolution(__lowerCAmelCase      )
									a_     :      Tuple 						=     self.normalization(__lowerCAmelCase      )
									a_     :      Any 						=     self.activation(__lowerCAmelCase      )
									return hidden_state




class 			snake_case_						(						nn.Module				):






							def __init__(   self			,     a_      ):
									super().__init__()
									a_     :      Dict 						=     ResNetConvLayer(
									    config.num_channels			,     config.embedding_size			,     kernel_size=7			,     stride=2			,     activation=config.hidden_act      )
									a_     :      Union[str, Any] 						=     nn.MaxPoolad(kernel_size=3			,     stride=2			,     padding=1      )
									a_     :      int 						=     config.num_channels






							def snake_case_  (   self			,     a_      ):
									a_     :      Optional[int] 						=     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."      )
									a_     :      Optional[Any] 						=     self.embedder(__lowerCAmelCase      )
									a_     :      List[str] 						=     self.pooler(__lowerCAmelCase      )
									return embedding




class 			snake_case_						(						nn.Module				):






							def __init__(   self			,     a_			,     a_			,     a_ = 2      ):
									super().__init__()
									a_     :      Any 						=     nn.Convad(__lowerCAmelCase			,     __lowerCAmelCase			,     kernel_size=1			,     stride=__lowerCAmelCase			,     bias=__lowerCAmelCase      )
									a_     :      Any 						=     nn.BatchNormad(__lowerCAmelCase      )






							def snake_case_  (   self			,     a_      ):
									a_     :      int 						=     self.convolution(__lowerCAmelCase      )
									a_     :      Optional[Any] 						=     self.normalization(__lowerCAmelCase      )
									return hidden_state




class 			snake_case_						(						nn.Module				):






							def __init__(   self			,     a_			,     a_			,     a_ = 1			,     a_ = "relu"      ):
									super().__init__()
									a_     :      str 						=     in_channels != out_channels or stride != 1
									a_     :      Tuple 						=     (
									    ResNetShortCut(__lowerCAmelCase			,     __lowerCAmelCase			,     stride=__lowerCAmelCase      ) if should_apply_shortcut else nn.Identity()
									)
									a_     :      List[str] 						=     nn.Sequential(
									    ResNetConvLayer(__lowerCAmelCase			,     __lowerCAmelCase			,     stride=__lowerCAmelCase      )			,     ResNetConvLayer(__lowerCAmelCase			,     __lowerCAmelCase			,     activation=__lowerCAmelCase      )			,     )
									a_     :      Dict 						=     ACTaFN[activation]






							def snake_case_  (   self			,     a_      ):
									a_     :      Optional[Any] 						=     hidden_state
									a_     :      str 						=     self.layer(__lowerCAmelCase      )
									a_     :      Union[str, Any] 						=     self.shortcut(__lowerCAmelCase      )
									hidden_state += residual
									a_     :      int 						=     self.activation(__lowerCAmelCase      )
									return hidden_state




class 			snake_case_						(						nn.Module				):






							def __init__(   self			,     a_			,     a_			,     a_ = 1			,     a_ = "relu"			,     a_ = 4      ):
									super().__init__()
									a_     :      Optional[int] 						=     in_channels != out_channels or stride != 1
									a_     :      Tuple 						=     out_channels // reduction
									a_     :      Optional[Any] 						=     (
									    ResNetShortCut(__lowerCAmelCase			,     __lowerCAmelCase			,     stride=__lowerCAmelCase      ) if should_apply_shortcut else nn.Identity()
									)
									a_     :      int 						=     nn.Sequential(
									    ResNetConvLayer(__lowerCAmelCase			,     __lowerCAmelCase			,     kernel_size=1      )			,     ResNetConvLayer(__lowerCAmelCase			,     __lowerCAmelCase			,     stride=__lowerCAmelCase      )			,     ResNetConvLayer(__lowerCAmelCase			,     __lowerCAmelCase			,     kernel_size=1			,     activation=__lowerCAmelCase      )			,     )
									a_     :      str 						=     ACTaFN[activation]






							def snake_case_  (   self			,     a_      ):
									a_     :      Dict 						=     hidden_state
									a_     :      Any 						=     self.layer(__lowerCAmelCase      )
									a_     :      Union[str, Any] 						=     self.shortcut(__lowerCAmelCase      )
									hidden_state += residual
									a_     :      Optional[Any] 						=     self.activation(__lowerCAmelCase      )
									return hidden_state




class 			snake_case_						(						nn.Module				):






							def __init__(   self			,     a_			,     a_			,     a_			,     a_ = 2			,     a_ = 2			,     ):
									super().__init__()

									a_     :      Optional[int] 						=     ResNetBottleNeckLayer if config.layer_type == "bottleneck" else ResNetBasicLayer

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






							def snake_case_  (   self			,     a_      ):
									a_     :      List[str] 						=     input
									for layer in self.layers:
											a_     :      Optional[int] 						=     layer(__lowerCAmelCase      )
									return hidden_state




class 			snake_case_						(						nn.Module				):






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






							def snake_case_  (   self			,     a_			,     a_ = False			,     a_ = True      ):
									a_     :      str 						=     () if output_hidden_states else None

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

											a_     :      int 						=     stage_module(__lowerCAmelCase      )

									if output_hidden_states:
											a_     :      str 						=     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=__lowerCAmelCase			,     hidden_states=__lowerCAmelCase			,     )




class 			snake_case_						(						a_				):
							__lowerCAmelCase    					=					ResNetConfig
							__lowerCAmelCase    					=					"resnet"
							__lowerCAmelCase    					=					"pixel_values"
							__lowerCAmelCase    					=					True






							def snake_case_  (   self			,     a_      ):







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






							def snake_case_  (   self			,     a_			,     a_=False      ):







									if isinstance(__lowerCAmelCase			,     __lowerCAmelCase      ):
											a_     :      str 						=     value

SCREAMING_SNAKE_CASE_				= r"""\n    This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. Use it\n    as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and\n    behavior.\n\n    Parameters:\n        config ([`ResNetConfig`]): Model configuration class with all the parameters of the model.\n            Initializing with a config file does not load the weights associated with the model, only the\n            configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.\n"""

SCREAMING_SNAKE_CASE_				= r"""\n    Args:\n        pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):\n            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See\n            [`ConvNextImageProcessor.__call__`] for details.\n\n        output_hidden_states (`bool`, *optional*):\n            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for\n            more detail.\n        return_dict (`bool`, *optional*):\n            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.\n"""




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






							def __init__(   self			,     a_      ):
									super().__init__(__lowerCAmelCase      )
									a_     :      Tuple 						=     config
									a_     :      Dict 						=     ResNetEmbeddings(__lowerCAmelCase      )
									a_     :      Optional[int] 						=     ResNetEncoder(__lowerCAmelCase      )
									a_     :      Union[str, Any] 						=     nn.AdaptiveAvgPoolad((1, 1)      )
									# Initialize weights and apply final processing
									self.post_init()






							@add_start_docstrings_to_model_forward(__lowerCAmelCase      )
							@add_code_sample_docstrings(
							    checkpoint=_CHECKPOINT_FOR_DOC			,     output_type=__lowerCAmelCase			,     config_class=_CONFIG_FOR_DOC			,     modality="vision"			,     expected_output=_EXPECTED_OUTPUT_SHAPE			,     )
							def snake_case_  (   self			,     a_			,     a_ = None			,     a_ = None      ):
									a_     :      Optional[int] 						=     (
									    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
									)
									a_     :      List[Any] 						=     return_dict if return_dict is not None else self.config.use_return_dict

									a_     :      int 						=     self.embedder(__lowerCAmelCase      )

									a_     :      Optional[Any] 						=     self.encoder(
									    __lowerCAmelCase			,     output_hidden_states=__lowerCAmelCase			,     return_dict=__lowerCAmelCase      )

									a_     :      Dict 						=     encoder_outputs[0]

									a_     :      str 						=     self.pooler(__lowerCAmelCase      )

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

									return BaseModelOutputWithPoolingAndNoAttention(
									    last_hidden_state=__lowerCAmelCase			,     pooler_output=__lowerCAmelCase			,     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    "     ,a_     ,)
class 			snake_case_						(						a_				):






							def __init__(   self			,     a_      ):
									super().__init__(__lowerCAmelCase      )
									a_     :      List[Any] 						=     config.num_labels
									a_     :      Optional[int] 						=     ResNetModel(__lowerCAmelCase      )
									# classification head
									a_     :      List[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(__lowerCAmelCase      )
							@add_code_sample_docstrings(
							    checkpoint=_IMAGE_CLASS_CHECKPOINT			,     output_type=__lowerCAmelCase			,     config_class=_CONFIG_FOR_DOC			,     expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT			,     )
							def snake_case_  (   self			,     a_ = None			,     a_ = None			,     a_ = None			,     a_ = None			,     ):
									a_     :      Optional[int] 						=     return_dict if return_dict is not None else self.config.use_return_dict

									a_     :      int 						=     self.resnet(__lowerCAmelCase			,     output_hidden_states=__lowerCAmelCase			,     return_dict=__lowerCAmelCase      )

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

									a_     :      Any 						=     self.classifier(__lowerCAmelCase      )

									a_     :      str 						=     None

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

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

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




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






							def __init__(   self			,     a_      ):
									super().__init__(__lowerCAmelCase      )
									super()._init_backbone(__lowerCAmelCase      )

									a_     :      Dict 						=     [config.embedding_size] + config.hidden_sizes
									a_     :      Optional[int] 						=     ResNetEmbeddings(__lowerCAmelCase      )
									a_     :      str 						=     ResNetEncoder(__lowerCAmelCase      )

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






							@add_start_docstrings_to_model_forward(__lowerCAmelCase      )
							@replace_return_docstrings(output_type=__lowerCAmelCase			,     config_class=_CONFIG_FOR_DOC      )
							def snake_case_  (   self			,     a_			,     a_ = None			,     a_ = None      ):
									a_     :      List[str] 						=     return_dict if return_dict is not None else self.config.use_return_dict
									a_     :      List[Any] 						=     (
									    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
									)

									a_     :      Optional[Any] 						=     self.embedder(__lowerCAmelCase      )

									a_     :      List[str] 						=     self.encoder(__lowerCAmelCase			,     output_hidden_states=__lowerCAmelCase			,     return_dict=__lowerCAmelCase      )

									a_     :      int 						=     outputs.hidden_states

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

									if not return_dict:
											a_     :      Optional[Any] 						=     (feature_maps,)
											if output_hidden_states:
													output += (outputs.hidden_states,)
											return output

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




"""simple docstring"""
SCREAMING_SNAKE_CASE_				= 0  # The first color of the flag.
SCREAMING_SNAKE_CASE_				= 1  # The second color of the flag.
SCREAMING_SNAKE_CASE_				= 2  # The third color of the flag.
SCREAMING_SNAKE_CASE_				= (red, white, blue)



def        lowerCAmelCase_						(							SCREAMING_SNAKE_CASE__	)			->      list:
		if not sequence:
				return []
		if len(SCREAMING_SNAKE_CASE__	) == 1:
				return list(SCREAMING_SNAKE_CASE__	)
		a_     :      Dict 						=     0
		a_     :      List[Any] 						=     len(SCREAMING_SNAKE_CASE__	) - 1
		a_     :      str 						=     0
		while mid <= high:
				if sequence[mid] == colors[0]:
						a_						,				a_     :      int 						=     sequence[mid], sequence[low]
						low += 1
						mid += 1
				elif sequence[mid] == colors[1]:
						mid += 1
				elif sequence[mid] == colors[2]:
						a_						,				a_     :      List[Any] 						=     sequence[high], sequence[mid]
						high -= 1
				else:
						a_     :      Dict 						=     F"""The elements inside the sequence must contains only {colors} values"""
						raise ValueError(SCREAMING_SNAKE_CASE__	)
		return sequence


if __name__ == "__main__":
					import doctest

					doctest.testmod()

					SCREAMING_SNAKE_CASE_				= input("""Enter numbers separated by commas:\n""").strip()
					SCREAMING_SNAKE_CASE_				= [int(item.strip()) for item in user_input.split(""",""")]
					print(F"""{dutch_national_flag_sort(unsorted)}""")