import argparse
from collections import defaultdict

import yaml


_lowercase:	List[Any]       			=		'''docs/source/en/_toctree.yml'''






def _lowerCamelCase  (		snake_case  ):
							_lowerCAmelCase							=							defaultdict(snake_case  )
							_lowerCAmelCase							=							[]
							_lowerCAmelCase							=							[]
							for doc in doc_list:
														if "local" in doc:
																					counts[doc["local"]] += 1

														if doc["title"].lower() == "overview":
																					overview_doc.append({'local': doc['local'], 'title': doc['title']}  )
														else:
																					new_doc_list.append(snake_case  )

							_lowerCAmelCase							=							new_doc_list
							_lowerCAmelCase							=							[key for key, value in counts.items() if value > 1]

							_lowerCAmelCase							=							[]
							for duplicate_key in duplicates:
														_lowerCAmelCase							=							list({doc['title'] for doc in doc_list if doc['local'] == duplicate_key}  )
														if len(snake_case  ) > 1:
																					raise ValueError(
																					    F'{duplicate_key} is present several times in the documentation table of content at '
																					    '`docs/source/en/_toctree.yml` with different *Title* values. Choose one of those and remove the '
																					    'others.'  )
														# Only add this once
														new_doc.append({'local': duplicate_key, 'title': titles[0]}  )

							# Add none duplicate-keys
							new_doc.extend([doc for doc in doc_list if 'local' not in counts or counts[doc['local']] == 1]  )
							_lowerCAmelCase							=							sorted(snake_case     , key=lambda snake_case  : s["title"].lower()  )

							# "overview" gets special treatment and is always first
							if len(snake_case  ) > 1:
														raise ValueError('{doc_list} has two \'overview\' docs which is not allowed.'  )

							overview_doc.extend(snake_case  )

							# Sort
							return overview_doc






def _lowerCamelCase  (		snake_case=False  ):
							with open(snake_case     , encoding='utf-8'  ) as f:
														_lowerCAmelCase							=							yaml.safe_load(f.read()  )

							# Get to the API doc
							_lowerCAmelCase							=							0
							while content[api_idx]["title"] != "API":
														api_idx += 1
							_lowerCAmelCase							=							content[api_idx]['sections']

							# Then to the model doc
							_lowerCAmelCase							=							0
							while api_doc[scheduler_idx]["title"] != "Schedulers":
														scheduler_idx += 1

							_lowerCAmelCase							=							api_doc[scheduler_idx]['sections']
							_lowerCAmelCase							=							clean_doc_toc(snake_case  )

							_lowerCAmelCase							=							False
							if new_scheduler_doc != scheduler_doc:
														_lowerCAmelCase							=							True
														if overwrite:
																					_lowerCAmelCase							=							new_scheduler_doc

							if diff:
														if overwrite:
																					_lowerCAmelCase							=							api_doc
																					with open(snake_case     , 'w'     , encoding='utf-8'  ) as f:
																												f.write(yaml.dump(snake_case     , allow_unicode=snake_case  )  )
														else:
																					raise ValueError(
																					    'The model doc part of the table of content is not properly sorted, run `make style` to fix this.'  )






def _lowerCamelCase  (		snake_case=False  ):
							with open(snake_case     , encoding='utf-8'  ) as f:
														_lowerCAmelCase							=							yaml.safe_load(f.read()  )

							# Get to the API doc
							_lowerCAmelCase							=							0
							while content[api_idx]["title"] != "API":
														api_idx += 1
							_lowerCAmelCase							=							content[api_idx]['sections']

							# Then to the model doc
							_lowerCAmelCase							=							0
							while api_doc[pipeline_idx]["title"] != "Pipelines":
														pipeline_idx += 1

							_lowerCAmelCase							=							False
							_lowerCAmelCase							=							api_doc[pipeline_idx]['sections']
							_lowerCAmelCase							=							[]

							# sort sub pipeline docs
							for pipeline_doc in pipeline_docs:
														if "section" in pipeline_doc:
																					_lowerCAmelCase							=							pipeline_doc['section']
																					_lowerCAmelCase							=							clean_doc_toc(snake_case  )
																					if overwrite:
																												_lowerCAmelCase							=							new_sub_pipeline_doc
														new_pipeline_docs.append(snake_case  )

							# sort overall pipeline doc
							_lowerCAmelCase							=							clean_doc_toc(snake_case  )

							if new_pipeline_docs != pipeline_docs:
														_lowerCAmelCase							=							True
														if overwrite:
																					_lowerCAmelCase							=							new_pipeline_docs

							if diff:
														if overwrite:
																					_lowerCAmelCase							=							api_doc
																					with open(snake_case     , 'w'     , encoding='utf-8'  ) as f:
																												f.write(yaml.dump(snake_case     , allow_unicode=snake_case  )  )
														else:
																					raise ValueError(
																					    'The model doc part of the table of content is not properly sorted, run `make style` to fix this.'  )


if __name__ == "__main__":
				_lowercase:	Tuple       			=		argparse.ArgumentParser()
				parser.add_argument('''--fix_and_overwrite''', action='''store_true''', help='''Whether to fix inconsistencies.''')
				_lowercase:	Optional[Any]       			=		parser.parse_args()

				check_scheduler_doc(args.fix_and_overwrite)
				check_pipeline_doc(args.fix_and_overwrite)







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 ...file_utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward
from ...modeling_outputs import (
    BaseModelOutputWithNoAttention,
    BaseModelOutputWithPoolingAndNoAttention,
    ImageClassifierOutputWithNoAttention,
)
from ...modeling_utils import PreTrainedModel
from ...utils import logging
from .configuration_regnet import RegNetConfig


_lowercase:	Any       			=		logging.get_logger(__name__)

# General docstring
_lowercase:	List[Any]       			=		'''RegNetConfig'''

# Base docstring
_lowercase:	List[Any]       			=		'''facebook/regnet-y-040'''
_lowercase:	int       			=		[1, 1_0_8_8, 7, 7]

# Image classification docstring
_lowercase:	Union[str, Any]       			=		'''facebook/regnet-y-040'''
_lowercase:	Tuple       			=		'''tabby, tabby cat'''

_lowercase:	str       			=		[
    '''facebook/regnet-y-040''',
    # See all regnet models at https://huggingface.co/models?filter=regnet
]



class        lowerCamelCase__				(   nn.Module				):





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





			def   SCREAMING_SNAKE_CASE__     (       self	:	str  ,  lowercase__	:	Union[str, Any]						):
										_lowerCAmelCase							=							self.convolution(lowercase__						)
										_lowerCAmelCase							=							self.normalization(lowercase__						)
										_lowerCAmelCase							=							self.activation(lowercase__						)
										return hidden_state







class        lowerCamelCase__				(   nn.Module				):





			def __init__(       self	:	int  ,  lowercase__	:	RegNetConfig						):
										super().__init__()
										_lowerCAmelCase							=							RegNetConvLayer(
										    config.num_channels  ,  config.embedding_size  ,  kernel_size=3  ,  stride=2  ,  activation=config.hidden_act						)
										_lowerCAmelCase							=							config.num_channels





			def   SCREAMING_SNAKE_CASE__     (       self	:	Optional[Any]  ,  lowercase__	:	Optional[int]						):
										_lowerCAmelCase							=							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.'						)
										_lowerCAmelCase							=							self.embedder(lowercase__						)
										return hidden_state







class        lowerCamelCase__				(   nn.Module				):





			def __init__(       self	:	Optional[Any]  ,  lowercase__	:	int  ,  lowercase__	:	int  ,  lowercase__	:	int = 2						):
										super().__init__()
										_lowerCAmelCase							=							nn.Convad(lowercase__  ,  lowercase__  ,  kernel_size=1  ,  stride=lowercase__  ,  bias=lowercase__						)
										_lowerCAmelCase							=							nn.BatchNormad(lowercase__						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	Tuple  ,  lowercase__	:	Tensor						):
										_lowerCAmelCase							=							self.convolution(lowercase__						)
										_lowerCAmelCase							=							self.normalization(lowercase__						)
										return hidden_state







class        lowerCamelCase__				(   nn.Module				):





			def __init__(       self	:	Optional[Any]  ,  lowercase__	:	int  ,  lowercase__	:	int						):
										super().__init__()

										_lowerCAmelCase							=							nn.AdaptiveAvgPoolad((1, 1)						)
										_lowerCAmelCase							=							nn.Sequential(
										    nn.Convad(lowercase__  ,  lowercase__  ,  kernel_size=1						)  ,  nn.ReLU()  ,  nn.Convad(lowercase__  ,  lowercase__  ,  kernel_size=1						)  ,  nn.Sigmoid()  ,  )





			def   SCREAMING_SNAKE_CASE__     (       self	:	Any  ,  lowercase__	:	List[Any]						):
										# b c h w -> b c 1 1
										_lowerCAmelCase							=							self.pooler(lowercase__						)
										_lowerCAmelCase							=							self.attention(lowercase__						)
										_lowerCAmelCase							=							hidden_state * attention
										return hidden_state







class        lowerCamelCase__				(   nn.Module				):





			def __init__(       self	:	Dict  ,  lowercase__	:	RegNetConfig  ,  lowercase__	:	int  ,  lowercase__	:	int  ,  lowercase__	:	int = 1						):
										super().__init__()
										_lowerCAmelCase							=							in_channels != out_channels or stride != 1
										_lowerCAmelCase							=							max(1  ,  out_channels // config.groups_width						)
										_lowerCAmelCase							=							(
										    RegNetShortCut(lowercase__  ,  lowercase__  ,  stride=lowercase__						) if should_apply_shortcut else nn.Identity()
										)
										_lowerCAmelCase							=							nn.Sequential(
										    RegNetConvLayer(lowercase__  ,  lowercase__  ,  kernel_size=1  ,  activation=config.hidden_act						)  ,  RegNetConvLayer(lowercase__  ,  lowercase__  ,  stride=lowercase__  ,  groups=lowercase__  ,  activation=config.hidden_act						)  ,  RegNetConvLayer(lowercase__  ,  lowercase__  ,  kernel_size=1  ,  activation=lowercase__						)  ,  )
										_lowerCAmelCase							=							ACTaFN[config.hidden_act]





			def   SCREAMING_SNAKE_CASE__     (       self	:	Dict  ,  lowercase__	:	Any						):
										_lowerCAmelCase							=							hidden_state
										_lowerCAmelCase							=							self.layer(lowercase__						)
										_lowerCAmelCase							=							self.shortcut(lowercase__						)
										hidden_state += residual
										_lowerCAmelCase							=							self.activation(lowercase__						)
										return hidden_state







class        lowerCamelCase__				(   nn.Module				):





			def __init__(       self	:	Any  ,  lowercase__	:	RegNetConfig  ,  lowercase__	:	int  ,  lowercase__	:	int  ,  lowercase__	:	int = 1						):
										super().__init__()
										_lowerCAmelCase							=							in_channels != out_channels or stride != 1
										_lowerCAmelCase							=							max(1  ,  out_channels // config.groups_width						)
										_lowerCAmelCase							=							(
										    RegNetShortCut(lowercase__  ,  lowercase__  ,  stride=lowercase__						) if should_apply_shortcut else nn.Identity()
										)
										_lowerCAmelCase							=							nn.Sequential(
										    RegNetConvLayer(lowercase__  ,  lowercase__  ,  kernel_size=1  ,  activation=config.hidden_act						)  ,  RegNetConvLayer(lowercase__  ,  lowercase__  ,  stride=lowercase__  ,  groups=lowercase__  ,  activation=config.hidden_act						)  ,  RegNetSELayer(lowercase__  ,  reduced_channels=int(round(in_channels / 4						)						)						)  ,  RegNetConvLayer(lowercase__  ,  lowercase__  ,  kernel_size=1  ,  activation=lowercase__						)  ,  )
										_lowerCAmelCase							=							ACTaFN[config.hidden_act]





			def   SCREAMING_SNAKE_CASE__     (       self	:	Optional[int]  ,  lowercase__	:	Tuple						):
										_lowerCAmelCase							=							hidden_state
										_lowerCAmelCase							=							self.layer(lowercase__						)
										_lowerCAmelCase							=							self.shortcut(lowercase__						)
										hidden_state += residual
										_lowerCAmelCase							=							self.activation(lowercase__						)
										return hidden_state







class        lowerCamelCase__				(   nn.Module				):





			def __init__(       self	:	Dict  ,  lowercase__	:	RegNetConfig  ,  lowercase__	:	int  ,  lowercase__	:	int  ,  lowercase__	:	int = 2  ,  lowercase__	:	int = 2  ,  ):
										super().__init__()

										_lowerCAmelCase							=							RegNetXLayer if config.layer_type == 'x' else RegNetYLayer

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





			def   SCREAMING_SNAKE_CASE__     (       self	:	Tuple  ,  lowercase__	:	Any						):
										_lowerCAmelCase							=							self.layers(lowercase__						)
										return hidden_state







class        lowerCamelCase__				(   nn.Module				):





			def __init__(       self	:	Dict  ,  lowercase__	:	RegNetConfig						):
										super().__init__()
										_lowerCAmelCase							=							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(
										    RegNetStage(
										        lowercase__  ,  config.embedding_size  ,  config.hidden_sizes[0]  ,  stride=2 if config.downsample_in_first_stage else 1  ,  depth=config.depths[0]  ,  )						)
										_lowerCAmelCase							=							zip(config.hidden_sizes  ,  config.hidden_sizes[1:]						)
										for (in_channels, out_channels), depth in zip(lowercase__  ,  config.depths[1:]						):
																	self.stages.append(RegNetStage(lowercase__  ,  lowercase__  ,  lowercase__  ,  depth=lowercase__						)						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	List[str]  ,  lowercase__	:	Tensor  ,  lowercase__	:	bool = False  ,  lowercase__	:	bool = True						):
										_lowerCAmelCase							=							() if output_hidden_states else None

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

																	_lowerCAmelCase							=							stage_module(lowercase__						)

										if output_hidden_states:
																	_lowerCAmelCase							=							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=lowercase__  ,  hidden_states=lowercase__						)







class        lowerCamelCase__				(   UpperCAmelCase				):
			UpperCamelCase__    							=RegNetConfig
			UpperCamelCase__    							="regnet"
			UpperCamelCase__    							="pixel_values"
			UpperCamelCase__    							=True





			def   SCREAMING_SNAKE_CASE__     (       self	:	Optional[int]  ,  lowercase__	:	List[Any]						):
										if isinstance(lowercase__  ,  nn.Convad						):
																	nn.init.kaiming_normal_(module.weight  ,  mode='fan_out'  ,  nonlinearity='relu'						)
										elif isinstance(lowercase__  ,  (nn.BatchNormad, nn.GroupNorm)						):
																	nn.init.constant_(module.weight  ,  1						)
																	nn.init.constant_(module.bias  ,  0						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	Any  ,  lowercase__	:	List[str]  ,  lowercase__	:	List[Any]=False						):
										if isinstance(lowercase__  ,  lowercase__						):
																	_lowerCAmelCase							=							value







_lowercase:	Optional[Any]       			=		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 ([`RegNetConfig`]): 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:	str       			=		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 [`~file_utils.ModelOutput`] instead of a plain tuple.
'''



@add_start_docstrings(
    "The bare RegNet model outputting raw features without any specific head on top."       ,UpperCAmelCase       ,)
# Copied from transformers.models.resnet.modeling_resnet.ResNetModel with RESNET->REGNET,ResNet->RegNet
class        lowerCamelCase__				(   UpperCAmelCase				):





			def __init__(       self	:	List[str]  ,  lowercase__	:	int						):
										super().__init__(lowercase__						)
										_lowerCAmelCase							=							config
										_lowerCAmelCase							=							RegNetEmbeddings(lowercase__						)
										_lowerCAmelCase							=							RegNetEncoder(lowercase__						)
										_lowerCAmelCase							=							nn.AdaptiveAvgPoolad((1, 1)						)
										# Initialize weights and apply final processing
										self.post_init()





			@add_start_docstrings_to_model_forward(lowercase__						)
			@add_code_sample_docstrings(
			    checkpoint=_CHECKPOINT_FOR_DOC  ,  output_type=lowercase__  ,  config_class=_CONFIG_FOR_DOC  ,  modality='vision'  ,  expected_output=_EXPECTED_OUTPUT_SHAPE  ,  )
			def   SCREAMING_SNAKE_CASE__     (       self	:	Any  ,  lowercase__	:	Tensor  ,  lowercase__	:	Optional[bool] = None  ,  lowercase__	:	Optional[bool] = None						):
										_lowerCAmelCase							=							(
										    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
										)
										_lowerCAmelCase							=							return_dict if return_dict is not None else self.config.use_return_dict

										_lowerCAmelCase							=							self.embedder(lowercase__						)

										_lowerCAmelCase							=							self.encoder(
										    lowercase__  ,  output_hidden_states=lowercase__  ,  return_dict=lowercase__						)

										_lowerCAmelCase							=							encoder_outputs[0]

										_lowerCAmelCase							=							self.pooler(lowercase__						)

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

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







@add_start_docstrings(
    "\n    RegNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for\n    ImageNet.\n    "       ,UpperCAmelCase       ,)
# Copied from transformers.models.resnet.modeling_resnet.ResNetForImageClassification with RESNET->REGNET,ResNet->RegNet,resnet->regnet
class        lowerCamelCase__				(   UpperCAmelCase				):





			def __init__(       self	:	str  ,  lowercase__	:	Union[str, Any]						):
										super().__init__(lowercase__						)
										_lowerCAmelCase							=							config.num_labels
										_lowerCAmelCase							=							RegNetModel(lowercase__						)
										# classification head
										_lowerCAmelCase							=							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(lowercase__						)
			@add_code_sample_docstrings(
			    checkpoint=_IMAGE_CLASS_CHECKPOINT  ,  output_type=lowercase__  ,  config_class=_CONFIG_FOR_DOC  ,  expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT  ,  )
			def   SCREAMING_SNAKE_CASE__     (       self	:	int  ,  lowercase__	:	Optional[torch.FloatTensor] = None  ,  lowercase__	:	Optional[torch.LongTensor] = None  ,  lowercase__	:	Optional[bool] = None  ,  lowercase__	:	Optional[bool] = None  ,  ):
										_lowerCAmelCase							=							return_dict if return_dict is not None else self.config.use_return_dict

										_lowerCAmelCase							=							self.regnet(lowercase__  ,  output_hidden_states=lowercase__  ,  return_dict=lowercase__						)

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

										_lowerCAmelCase							=							self.classifier(lowercase__						)

										_lowerCAmelCase							=							None

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

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

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






