


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, 2_0_4_8, 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       A    (   nn.Module ):


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







							def 			_A       (self      ,				lowerCAmelCase					):
									__lowercase=			self.convolution(lowerCAmelCase					)
									__lowercase=			self.normalization(lowerCAmelCase					)
									__lowercase=			self.activation(lowerCAmelCase					)
									return hidden_state





class       A    (   nn.Module ):


							def __init__(self      ,				lowerCAmelCase					):
									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      ,				lowerCAmelCase					):
									__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(lowerCAmelCase					)
									__lowercase=			self.pooler(lowerCAmelCase					)
									return embedding





class       A    (   nn.Module ):


							def __init__(self      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase = 2					):
									super().__init__()
									__lowercase=			nn.Convad(lowerCAmelCase      ,				lowerCAmelCase      ,				kernel_size=1      ,				stride=lowerCAmelCase      ,				bias=lowerCAmelCase					)
									__lowercase=			nn.BatchNormad(lowerCAmelCase					)







							def 			_A       (self      ,				lowerCAmelCase					):
									__lowercase=			self.convolution(lowerCAmelCase					)
									__lowercase=			self.normalization(lowerCAmelCase					)
									return hidden_state





class       A    (   nn.Module ):


							def __init__(self      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase = 1      ,				lowerCAmelCase = "relu"					):
									super().__init__()
									__lowercase=			in_channels != out_channels or stride != 1
									__lowercase=			(
									    ResNetShortCut(lowerCAmelCase      ,				lowerCAmelCase      ,				stride=lowerCAmelCase					) if should_apply_shortcut else nn.Identity()
									)
									__lowercase=			nn.Sequential(
									    ResNetConvLayer(lowerCAmelCase      ,				lowerCAmelCase      ,				stride=lowerCAmelCase					)      ,				ResNetConvLayer(lowerCAmelCase      ,				lowerCAmelCase      ,				activation=lowerCAmelCase					)      ,				)
									__lowercase=			ACTaFN[activation]







							def 			_A       (self      ,				lowerCAmelCase					):
									__lowercase=			hidden_state
									__lowercase=			self.layer(lowerCAmelCase					)
									__lowercase=			self.shortcut(lowerCAmelCase					)
									hidden_state += residual
									__lowercase=			self.activation(lowerCAmelCase					)
									return hidden_state





class       A    (   nn.Module ):


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







							def 			_A       (self      ,				lowerCAmelCase					):
									__lowercase=			hidden_state
									__lowercase=			self.layer(lowerCAmelCase					)
									__lowercase=			self.shortcut(lowerCAmelCase					)
									hidden_state += residual
									__lowercase=			self.activation(lowerCAmelCase					)
									return hidden_state





class       A    (   nn.Module ):


							def __init__(self      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase = 2      ,				lowerCAmelCase = 2      ,				):
									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(lowerCAmelCase      ,				lowerCAmelCase      ,				stride=lowerCAmelCase      ,				activation=config.hidden_act					)      ,				*[layer(lowerCAmelCase      ,				lowerCAmelCase      ,				activation=config.hidden_act					) for _ in range(depth - 1					)]      ,				)







							def 			_A       (self      ,				lowerCAmelCase					):
									__lowercase=			input
									for layer in self.layers:
											__lowercase=			layer(lowerCAmelCase					)
									return hidden_state





class       A    (   nn.Module ):


							def __init__(self      ,				lowerCAmelCase					):
									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(
									        lowerCAmelCase      ,				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(lowerCAmelCase      ,				config.depths[1:]					):
											self.stages.append(ResNetStage(lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				depth=lowerCAmelCase					)					)







							def 			_A       (self      ,				lowerCAmelCase      ,				lowerCAmelCase = False      ,				lowerCAmelCase = True					):
									__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(lowerCAmelCase					)

									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=lowerCAmelCase      ,				hidden_states=lowerCAmelCase      ,				)





class       A    (   A_ ):
							UpperCamelCase_   :							Any       =ResNetConfig
							UpperCamelCase_   :							Optional[int]       ='''resnet'''
							UpperCamelCase_   :							Optional[Any]       ='''pixel_values'''
							UpperCamelCase_   :							Tuple       =True


							def 			_A       (self      ,				lowerCAmelCase					):
									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 			_A       (self      ,				lowerCAmelCase      ,				lowerCAmelCase=False					):
									if isinstance(lowerCAmelCase      ,				lowerCAmelCase					):
											__lowercase=			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.'''					,				A_					,				)
class       A    (   A_ ):


							def __init__(self      ,				lowerCAmelCase					):
									super().__init__(lowerCAmelCase					)
									__lowercase=			config
									__lowercase=			ResNetEmbeddings(lowerCAmelCase					)
									__lowercase=			ResNetEncoder(lowerCAmelCase					)
									__lowercase=			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 			_A       (self      ,				lowerCAmelCase      ,				lowerCAmelCase = None      ,				lowerCAmelCase = None					):
									__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(lowerCAmelCase					)

									__lowercase=			self.encoder(
									    lowerCAmelCase      ,				output_hidden_states=lowerCAmelCase      ,				return_dict=lowerCAmelCase					)

									__lowercase=			encoder_outputs[0]

									__lowercase=			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(
    '''
    ResNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for
    ImageNet.
    '''					,				A_					,				)
class       A    (   A_ ):


							def __init__(self      ,				lowerCAmelCase					):
									super().__init__(lowerCAmelCase					)
									__lowercase=			config.num_labels
									__lowercase=			ResNetModel(lowerCAmelCase					)
									# 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(lowerCAmelCase					)
							@add_code_sample_docstrings(
							    checkpoint=_IMAGE_CLASS_CHECKPOINT      ,				output_type=lowerCAmelCase      ,				config_class=_CONFIG_FOR_DOC      ,				expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT      ,				)
							def 			_A       (self      ,				lowerCAmelCase = None      ,				lowerCAmelCase = None      ,				lowerCAmelCase = None      ,				lowerCAmelCase = None      ,				):
									__lowercase=			return_dict if return_dict is not None else self.config.use_return_dict

									__lowercase=			self.resnet(lowerCAmelCase      ,				output_hidden_states=lowerCAmelCase      ,				return_dict=lowerCAmelCase					)

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

									__lowercase=			self.classifier(lowerCAmelCase					)

									__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(lowerCAmelCase      ,				lowerCAmelCase					)
											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(lowerCAmelCase      ,				lowerCAmelCase					)

									if not return_dict:
											__lowercase=			(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(
    '''
    ResNet backbone, to be used with frameworks like DETR and MaskFormer.
    '''					,				A_					,				)
class       A    (   A_					,				A_ ):


							def __init__(self      ,				lowerCAmelCase					):
									super().__init__(lowerCAmelCase					)
									super()._init_backbone(lowerCAmelCase					)

									__lowercase=			[config.embedding_size] + config.hidden_sizes
									__lowercase=			ResNetEmbeddings(lowerCAmelCase					)
									__lowercase=			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 			_A       (self      ,				lowerCAmelCase      ,				lowerCAmelCase = None      ,				lowerCAmelCase = None					):
									__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(lowerCAmelCase					)

									__lowercase=			self.encoder(lowerCAmelCase      ,				output_hidden_states=lowerCAmelCase      ,				return_dict=lowerCAmelCase					)

									__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=lowerCAmelCase      ,				hidden_states=outputs.hidden_states if output_hidden_states else None      ,				attentions=lowerCAmelCase      ,				)










def        _lowerCamelCase(	lowercase__	)						->	int:

		'''simple docstring'''







		if collection == []:
				return []

		# get some information about the collection
		__lowercase=			len(lowercase__	)
		__lowercase=			max(lowercase__	)
		__lowercase=			min(lowercase__	)

		# create the counting array
		__lowercase=			coll_max + 1 - coll_min
		__lowercase=			[0] * counting_arr_length

		# count how much a number appears in the collection
		for number in collection:
				counting_arr[number - coll_min] += 1

		# sum each position with it's predecessors. now, counting_arr[i] tells
		# us how many elements <= i has in the collection
		for i in range(1   , lowercase__	):
				__lowercase=			counting_arr[i] + counting_arr[i - 1]

		# create the output collection
		__lowercase=			[0] * coll_len

		# place the elements in the output, respecting the original order (stable
		# sort) from end to begin, updating counting_arr
		for i in reversed(range(0   , lowercase__	)	):
				__lowercase=			collection[i]
				counting_arr[collection[i] - coll_min] -= 1

		return ordered







def        _lowerCamelCase(	lowercase__	)						->	List[str]:

		'''simple docstring'''







		return "".join([chr(lowercase__	) for i in counting_sort([ord(lowercase__	) for c in string]	)]	)


if __name__ == "__main__":
	# Test string sort
	assert counting_sort_string('''thisisthestring''') == "eghhiiinrsssttt"

	lowerCAmelCase           =		input('''Enter numbers separated by a comma:\n''').strip()
	lowerCAmelCase           =		[int(item) for item in user_input.split(''',''')]
	print(counting_sort(unsorted))






