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


SCREAMING_SNAKE_CASE__      						=  logging.get_logger(__name__)

# General docstring
SCREAMING_SNAKE_CASE__      						=  "RegNetConfig"

# Base docstring
SCREAMING_SNAKE_CASE__      						=  "facebook/regnet-y-040"
SCREAMING_SNAKE_CASE__      						=  [1, 1_088, 7, 7]

# Image classification docstring
SCREAMING_SNAKE_CASE__      						=  "facebook/regnet-y-040"
SCREAMING_SNAKE_CASE__      						=  "tabby, tabby cat"

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



class   lowerCAmelCase_    (			nn.Module					):



				"""simple docstring"""

				def __init__(				self		,    lowerCAmelCase		,    lowerCAmelCase		,    lowerCAmelCase = 3		,    lowerCAmelCase = 1		,    lowerCAmelCase = 1		,    lowerCAmelCase = "relu"		,    ):






										"""simple docstring"""

										super().__init__()
										snake_case								=			nn.Convad(
										    lowerCAmelCase		,    lowerCAmelCase		,    kernel_size=lowerCAmelCase		,    stride=lowerCAmelCase		,    padding=kernel_size // 2		,    groups=lowerCAmelCase		,    bias=lowerCAmelCase		,    )
										snake_case								=			nn.BatchNormad(lowerCAmelCase    )
										snake_case								=			ACTaFN[activation] if activation is not None else nn.Identity()

				def 		snake_case (				self		,    lowerCAmelCase    ):






										"""simple docstring"""

										snake_case								=			self.convolution(lowerCAmelCase    )
										snake_case								=			self.normalization(lowerCAmelCase    )
										snake_case								=			self.activation(lowerCAmelCase    )
										return hidden_state





class   lowerCAmelCase_    (			nn.Module					):



				"""simple docstring"""

				def __init__(				self		,    lowerCAmelCase    ):






										"""simple docstring"""

										super().__init__()
										snake_case								=			RegNetConvLayer(
										    config.num_channels		,    config.embedding_size		,    kernel_size=3		,    stride=2		,    activation=config.hidden_act    )
										snake_case								=			config.num_channels

				def 		snake_case (				self		,    lowerCAmelCase    ):






										"""simple docstring"""

										snake_case								=			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.'    )
										snake_case								=			self.embedder(lowerCAmelCase    )
										return hidden_state





class   lowerCAmelCase_    (			nn.Module					):



				"""simple docstring"""

				def __init__(				self		,    lowerCAmelCase		,    lowerCAmelCase		,    lowerCAmelCase = 2    ):






										"""simple docstring"""

										super().__init__()
										snake_case								=			nn.Convad(lowerCAmelCase		,    lowerCAmelCase		,    kernel_size=1		,    stride=lowerCAmelCase		,    bias=lowerCAmelCase    )
										snake_case								=			nn.BatchNormad(lowerCAmelCase    )

				def 		snake_case (				self		,    lowerCAmelCase    ):






										"""simple docstring"""

										snake_case								=			self.convolution(lowerCAmelCase    )
										snake_case								=			self.normalization(lowerCAmelCase    )
										return hidden_state





class   lowerCAmelCase_    (			nn.Module					):



				"""simple docstring"""

				def __init__(				self		,    lowerCAmelCase		,    lowerCAmelCase    ):






										"""simple docstring"""

										super().__init__()

										snake_case								=			nn.AdaptiveAvgPoolad((1, 1)    )
										snake_case								=			nn.Sequential(
										    nn.Convad(lowerCAmelCase		,    lowerCAmelCase		,    kernel_size=1    )		,    nn.ReLU()		,    nn.Convad(lowerCAmelCase		,    lowerCAmelCase		,    kernel_size=1    )		,    nn.Sigmoid()		,    )

				def 		snake_case (				self		,    lowerCAmelCase    ):






										"""simple docstring"""

										snake_case								=			self.pooler(lowerCAmelCase    )
										snake_case								=			self.attention(lowerCAmelCase    )
										snake_case								=			hidden_state * attention
										return hidden_state





class   lowerCAmelCase_    (			nn.Module					):



				"""simple docstring"""

				def __init__(				self		,    lowerCAmelCase		,    lowerCAmelCase		,    lowerCAmelCase		,    lowerCAmelCase = 1    ):






										"""simple docstring"""

										super().__init__()
										snake_case								=			in_channels != out_channels or stride != 1
										snake_case								=			max(1		,    out_channels // config.groups_width    )
										snake_case								=			(
										    RegNetShortCut(lowerCAmelCase		,    lowerCAmelCase		,    stride=lowerCAmelCase    ) if should_apply_shortcut else nn.Identity()
										)
										snake_case								=			nn.Sequential(
										    RegNetConvLayer(lowerCAmelCase		,    lowerCAmelCase		,    kernel_size=1		,    activation=config.hidden_act    )		,    RegNetConvLayer(lowerCAmelCase		,    lowerCAmelCase		,    stride=lowerCAmelCase		,    groups=lowerCAmelCase		,    activation=config.hidden_act    )		,    RegNetConvLayer(lowerCAmelCase		,    lowerCAmelCase		,    kernel_size=1		,    activation=lowerCAmelCase    )		,    )
										snake_case								=			ACTaFN[config.hidden_act]

				def 		snake_case (				self		,    lowerCAmelCase    ):






										"""simple docstring"""

										snake_case								=			hidden_state
										snake_case								=			self.layer(lowerCAmelCase    )
										snake_case								=			self.shortcut(lowerCAmelCase    )
										hidden_state += residual
										snake_case								=			self.activation(lowerCAmelCase    )
										return hidden_state





class   lowerCAmelCase_    (			nn.Module					):



				"""simple docstring"""

				def __init__(				self		,    lowerCAmelCase		,    lowerCAmelCase		,    lowerCAmelCase		,    lowerCAmelCase = 1    ):






										"""simple docstring"""

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

				def 		snake_case (				self		,    lowerCAmelCase    ):






										"""simple docstring"""

										snake_case								=			hidden_state
										snake_case								=			self.layer(lowerCAmelCase    )
										snake_case								=			self.shortcut(lowerCAmelCase    )
										hidden_state += residual
										snake_case								=			self.activation(lowerCAmelCase    )
										return hidden_state





class   lowerCAmelCase_    (			nn.Module					):



				"""simple docstring"""

				def __init__(				self		,    lowerCAmelCase		,    lowerCAmelCase		,    lowerCAmelCase		,    lowerCAmelCase = 2		,    lowerCAmelCase = 2		,    ):






										"""simple docstring"""

										super().__init__()

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

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

				def 		snake_case (				self		,    lowerCAmelCase    ):






										"""simple docstring"""

										snake_case								=			self.layers(lowerCAmelCase    )
										return hidden_state





class   lowerCAmelCase_    (			nn.Module					):



				"""simple docstring"""

				def __init__(				self		,    lowerCAmelCase    ):






										"""simple docstring"""

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

				def 		snake_case (				self		,    lowerCAmelCase		,    lowerCAmelCase = False		,    lowerCAmelCase = True    ):






										"""simple docstring"""

										snake_case								=			() if output_hidden_states else None

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

																snake_case								=			stage_module(lowerCAmelCase    )

										if output_hidden_states:
																snake_case								=			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   lowerCAmelCase_    (			lowerCAmelCase					):



				"""simple docstring"""
				_lowerCAmelCase     :    List[str]			  =						RegNetConfig
				_lowerCAmelCase     :    str			  =						"""regnet"""
				_lowerCAmelCase     :    Any			  =						"""pixel_values"""
				_lowerCAmelCase     :    Tuple			  =						True

				def 		snake_case (				self		,    lowerCAmelCase    ):






										"""simple docstring"""

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






										"""simple docstring"""

										if isinstance(lowerCAmelCase		,    lowerCAmelCase    ):
																snake_case								=			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 ([`RegNetConfig`]): 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 [`~file_utils.ModelOutput`] instead of a plain tuple.\n"



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



				"""simple docstring"""

				def __init__(				self		,    lowerCAmelCase    ):






										"""simple docstring"""

										super().__init__(lowerCAmelCase    )
										snake_case								=			config
										snake_case								=			RegNetEmbeddings(lowerCAmelCase    )
										snake_case								=			RegNetEncoder(lowerCAmelCase    )
										snake_case								=			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		,    lowerCAmelCase		,    lowerCAmelCase = None		,    lowerCAmelCase = None    ):






										"""simple docstring"""

										snake_case								=			(
										    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
										)
										snake_case								=			return_dict if return_dict is not None else self.config.use_return_dict

										snake_case								=			self.embedder(lowerCAmelCase    )

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

										snake_case								=			encoder_outputs[0]

										snake_case								=			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(
    """
    RegNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for
    ImageNet.
    """     ,    lowerCAmelCase     ,    )
# Copied from transformers.models.resnet.modeling_resnet.ResNetForImageClassification with RESNET->REGNET,ResNet->RegNet,resnet->regnet
class   lowerCAmelCase_    (			lowerCAmelCase					):



				"""simple docstring"""

				def __init__(				self		,    lowerCAmelCase    ):






										"""simple docstring"""

										super().__init__(lowerCAmelCase    )
										snake_case								=			config.num_labels
										snake_case								=			RegNetModel(lowerCAmelCase    )
										# classification head
										snake_case								=			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		,    lowerCAmelCase = None		,    lowerCAmelCase = None		,    lowerCAmelCase = None		,    lowerCAmelCase = None		,    ):






										"""simple docstring"""

										snake_case								=			return_dict if return_dict is not None else self.config.use_return_dict

										snake_case								=			self.regnet(lowerCAmelCase		,    output_hidden_states=lowerCAmelCase		,    return_dict=lowerCAmelCase    )

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

										snake_case								=			self.classifier(lowerCAmelCase    )

										snake_case								=			None

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

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

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



"""simple docstring"""
import numpy as np
from PIL import Image





def    lowerCAmelCase__    (			_UpperCamelCase       :				np.ndarray ,			_UpperCamelCase       :				int ,			_UpperCamelCase       :				int					)					->				np.ndarray:





						"""simple docstring"""






						snake_case								=			np.array(_UpperCamelCase					)
						if arr.shape[0] != arr.shape[1]:
												raise ValueError('The input array is not a square matrix'					)
						snake_case								=			0
						snake_case								=			0
						snake_case								=			0
						snake_case								=			0

						# compute the shape of the output matrix
						snake_case								=			(arr.shape[0] - size) // stride + 1
						# initialize the output matrix with zeros of shape maxpool_shape
						snake_case								=			np.zeros((maxpool_shape, maxpool_shape)					)

						while i < arr.shape[0]:
												if i + size > arr.shape[0]:
																		# if the end of the matrix is reached, break
																		break
												while j < arr.shape[1]:
																		# if the end of the matrix is reached, break
																		if j + size > arr.shape[1]:
																								break
																		# compute the maximum of the pooling matrix
																		snake_case								=			np.max(arr[i : i + size, j : j + size]					)
																		# shift the pooling matrix by stride of column pixels
																		j += stride
																		mat_j += 1

												# shift the pooling matrix by stride of row pixels
												i += stride
												mat_i += 1

												# reset the column index to 0
												snake_case								=			0
												snake_case								=			0

						return updated_arr





def    lowerCAmelCase__    (			_UpperCamelCase       :				np.ndarray ,			_UpperCamelCase       :				int ,			_UpperCamelCase       :				int					)					->				np.ndarray:





						"""simple docstring"""






						snake_case								=			np.array(_UpperCamelCase					)
						if arr.shape[0] != arr.shape[1]:
												raise ValueError('The input array is not a square matrix'					)
						snake_case								=			0
						snake_case								=			0
						snake_case								=			0
						snake_case								=			0

						# compute the shape of the output matrix
						snake_case								=			(arr.shape[0] - size) // stride + 1
						# initialize the output matrix with zeros of shape avgpool_shape
						snake_case								=			np.zeros((avgpool_shape, avgpool_shape)					)

						while i < arr.shape[0]:
												# if the end of the matrix is reached, break
												if i + size > arr.shape[0]:
																		break
												while j < arr.shape[1]:
																		# if the end of the matrix is reached, break
																		if j + size > arr.shape[1]:
																								break
																		# compute the average of the pooling matrix
																		snake_case								=			int(np.average(arr[i : i + size, j : j + size]					)					)
																		# shift the pooling matrix by stride of column pixels
																		j += stride
																		mat_j += 1

												# shift the pooling matrix by stride of row pixels
												i += stride
												mat_i += 1
												# reset the column index to 0
												snake_case								=			0
												snake_case								=			0

						return updated_arr


# Main Function
if __name__ == "__main__":
					from doctest import testmod

					testmod(name="avgpooling", verbose=True)

					# Loading the image
					SCREAMING_SNAKE_CASE__      						=  Image.open("path_to_image")

					# Converting the image to numpy array and maxpooling, displaying the result
					# Ensure that the image is a square matrix

					Image.fromarray(maxpooling(np.array(image), size=3, stride=2)).show()

					# Converting the image to numpy array and averagepooling, displaying the result
					# Ensure that the image is a square matrix

					Image.fromarray(avgpooling(np.array(image), size=3, stride=2)).show()


