



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


lowercase  							=					logging.get_logger(__name__)

# General docstring
lowercase  							=					'''ResNetConfig'''

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

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

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




class 			lowercase__			(      nn.Module    ):
							'''simple docstring'''







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






							def        lowerCamelCase_   (  self	,       snake_case						)			->							Tensor:
									_UpperCAmelCase							 =		self.convolution(snake_case						)
									_UpperCAmelCase							 =		self.normalization(snake_case						)
									_UpperCAmelCase							 =		self.activation(snake_case						)
									return hidden_state







class 			lowercase__			(      nn.Module    ):
							'''simple docstring'''







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






							def        lowerCamelCase_   (  self	,       snake_case						)			->							Tensor:
									_UpperCAmelCase							 =		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.'						)
									_UpperCAmelCase							 =		self.embedder(snake_case						)
									_UpperCAmelCase							 =		self.pooler(snake_case						)
									return embedding







class 			lowercase__			(      nn.Module    ):
							'''simple docstring'''







							def __init__(  self	,       snake_case	,       snake_case	,       snake_case = 2						)			->							Union[str, Any]:
									super().__init__()
									_UpperCAmelCase							 =		nn.Convad(snake_case	,       snake_case	,       kernel_size=1	,       stride=snake_case	,       bias=snake_case						)
									_UpperCAmelCase							 =		nn.BatchNormad(snake_case						)






							def        lowerCamelCase_   (  self	,       snake_case						)			->							Tensor:
									_UpperCAmelCase							 =		self.convolution(snake_case						)
									_UpperCAmelCase							 =		self.normalization(snake_case						)
									return hidden_state







class 			lowercase__			(      nn.Module    ):
							'''simple docstring'''







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






							def        lowerCamelCase_   (  self	,       snake_case						)			->							List[Any]:
									_UpperCAmelCase							 =		hidden_state
									_UpperCAmelCase							 =		self.layer(snake_case						)
									_UpperCAmelCase							 =		self.shortcut(snake_case						)
									hidden_state += residual
									_UpperCAmelCase							 =		self.activation(snake_case						)
									return hidden_state







class 			lowercase__			(      nn.Module    ):
							'''simple docstring'''







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






							def        lowerCamelCase_   (  self	,       snake_case						)			->							int:
									_UpperCAmelCase							 =		hidden_state
									_UpperCAmelCase							 =		self.layer(snake_case						)
									_UpperCAmelCase							 =		self.shortcut(snake_case						)
									hidden_state += residual
									_UpperCAmelCase							 =		self.activation(snake_case						)
									return hidden_state







class 			lowercase__			(      nn.Module    ):
							'''simple docstring'''







							def __init__(  self	,       snake_case	,       snake_case	,       snake_case	,       snake_case = 2	,       snake_case = 2	,       )			->							Optional[int]:
									super().__init__()

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

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






							def        lowerCamelCase_   (  self	,       snake_case						)			->							Tensor:
									_UpperCAmelCase							 =		input
									for layer in self.layers:
											_UpperCAmelCase							 =		layer(snake_case						)
									return hidden_state







class 			lowercase__			(      nn.Module    ):
							'''simple docstring'''







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






							def        lowerCamelCase_   (  self	,       snake_case	,       snake_case = False	,       snake_case = True						)			->							BaseModelOutputWithNoAttention:
									_UpperCAmelCase							 =		() if output_hidden_states else None

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

											_UpperCAmelCase							 =		stage_module(snake_case						)

									if output_hidden_states:
											_UpperCAmelCase							 =		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=snake_case	,       hidden_states=snake_case	,       )







class 			lowercase__			(      A    ):
							'''simple docstring'''







							_UpperCAmelCase      				=					ResNetConfig
							_UpperCAmelCase      				=					'''resnet'''
							_UpperCAmelCase      				=					'''pixel_values'''
							_UpperCAmelCase      				=					True






							def        lowerCamelCase_   (  self	,       snake_case						)			->							str:
									if isinstance(snake_case	,       nn.Convad						):
											nn.init.kaiming_normal_(module.weight	,       mode='fan_out'	,       nonlinearity='relu'						)
									elif isinstance(snake_case	,       (nn.BatchNormad, nn.GroupNorm)						):
											nn.init.constant_(module.weight	,       1						)
											nn.init.constant_(module.bias	,       0						)






							def        lowerCamelCase_   (  self	,       snake_case	,       snake_case=False						)			->							Optional[Any]:
									if isinstance(snake_case	,       snake_case						):
											_UpperCAmelCase							 =		value







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

lowercase  							=					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 			lowercase__			(      A    ):
							'''simple docstring'''







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






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

									_UpperCAmelCase							 =		self.embedder(snake_case						)

									_UpperCAmelCase							 =		self.encoder(
									    snake_case	,       output_hidden_states=snake_case	,       return_dict=snake_case						)

									_UpperCAmelCase							 =		encoder_outputs[0]

									_UpperCAmelCase							 =		self.pooler(snake_case						)

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

									return BaseModelOutputWithPoolingAndNoAttention(
									    last_hidden_state=snake_case	,       pooler_output=snake_case	,       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 			lowercase__			(      A    ):
							'''simple docstring'''







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

									_UpperCAmelCase							 =		self.resnet(snake_case	,       output_hidden_states=snake_case	,       return_dict=snake_case						)

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

									_UpperCAmelCase							 =		self.classifier(snake_case						)

									_UpperCAmelCase							 =		None

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

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

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







@add_start_docstrings(
    '''
    ResNet backbone, to be used with frameworks like DETR and MaskFormer.
    ''',					A,					)
class 			lowercase__			(      A,					A    ):
							'''simple docstring'''







							def __init__(  self	,       snake_case						)			->							List[str]:
									super().__init__(snake_case						)
									super()._init_backbone(snake_case						)

									_UpperCAmelCase							 =		[config.embedding_size] + config.hidden_sizes
									_UpperCAmelCase							 =		ResNetEmbeddings(snake_case						)
									_UpperCAmelCase							 =		ResNetEncoder(snake_case						)

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






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

									_UpperCAmelCase							 =		self.embedder(snake_case						)

									_UpperCAmelCase							 =		self.encoder(snake_case	,       output_hidden_states=snake_case	,       return_dict=snake_case						)

									_UpperCAmelCase							 =		outputs.hidden_states

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

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

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







"""simple docstring"""





import os

lowercase  							=					{'''I''': 1, '''V''': 5, '''X''': 10, '''L''': 50, '''C''': 1_00, '''D''': 5_00, '''M''': 10_00}




def 	UpperCAmelCase     (		A	:						str       ):

		'''simple docstring'''


		_UpperCAmelCase							 =		0

		_UpperCAmelCase							 =		0
		while index < len(A       ) - 1:
				_UpperCAmelCase							 =		SYMBOLS[numerals[index]]
				_UpperCAmelCase							 =		SYMBOLS[numerals[index + 1]]
				if current_value < next_value:
						total_value -= current_value
				else:
						total_value += current_value
				index += 1
		total_value += SYMBOLS[numerals[index]]

		return total_value




def 	UpperCAmelCase     (		A	:						int       ):

		'''simple docstring'''


		_UpperCAmelCase							 =		''

		_UpperCAmelCase							 =		num // 1000
		numerals += m_count * "M"
		num %= 1000

		_UpperCAmelCase							 =		num // 100
		if c_count == 9:
				numerals += "CM"
				c_count -= 9
		elif c_count == 4:
				numerals += "CD"
				c_count -= 4
		if c_count >= 5:
				numerals += "D"
				c_count -= 5
		numerals += c_count * "C"
		num %= 100

		_UpperCAmelCase							 =		num // 10
		if x_count == 9:
				numerals += "XC"
				x_count -= 9
		elif x_count == 4:
				numerals += "XL"
				x_count -= 4
		if x_count >= 5:
				numerals += "L"
				x_count -= 5
		numerals += x_count * "X"
		num %= 10

		if num == 9:
				numerals += "IX"
				num -= 9
		elif num == 4:
				numerals += "IV"
				num -= 4
		if num >= 5:
				numerals += "V"
				num -= 5
		numerals += num * "I"

		return numerals




def 	UpperCAmelCase     (		A	:						str = "/p089_roman.txt"       ):

		'''simple docstring'''


		_UpperCAmelCase							 =		0

		with open(os.path.dirname(A       ) + roman_numerals_filename       ) as filea:
				_UpperCAmelCase							 =		filea.readlines()

		for line in lines:
				_UpperCAmelCase							 =		line.strip()
				_UpperCAmelCase							 =		parse_roman_numerals(A       )
				_UpperCAmelCase							 =		generate_roman_numerals(A       )
				savings += len(A       ) - len(A       )

		return savings


if __name__ == "__main__":
					print(F'''{solution() = }''')


