
from typing import List, Optional, Tuple, Union

import torch
from torch import nn
from torch.nn import CrossEntropyLoss

from ... import AutoBackbone
from ...modeling_outputs import SemanticSegmenterOutput
from ...modeling_utils import PreTrainedModel
from ...utils import add_start_docstrings, add_start_docstrings_to_model_forward, replace_return_docstrings
from ...utils.backbone_utils import BackboneMixin
from .configuration_upernet import UperNetConfig


lowercase						:      List[Any]									= [
    'openmmlab/upernet-convnext-tiny',
    # See all UperNet models at https://huggingface.co/models?filter=upernet
]

# General docstring
lowercase						:      str									= 'UperNetConfig'




class 				lowerCamelCase__							(       nn.Module):




	'''simple docstring'''




	def __init__(      self	:Tuple  ,     a	:int  ,     a	:int  ,     a	:Union[int, Tuple[int, int]]  ,     a	:Union[int, Tuple[int, int], str] = 0  ,     a	:bool = False  ,     a	:Union[int, Tuple[int, int]] = 1  ,     )	->				None:
								super().__init__()
								__UpperCamelCase			:     List[Any]         =      nn.Convad(
								    in_channels=a  ,     out_channels=a  ,     kernel_size=a  ,     padding=a  ,     bias=a  ,     dilation=a  ,     )
								__UpperCamelCase			:     Any         =      nn.BatchNormad(a		)
								__UpperCamelCase			:     Optional[Any]         =      nn.ReLU()







	def      _lowerCamelCase       (      self	:List[str]  ,     a	:torch.Tensor		)	->				torch.Tensor:
								__UpperCamelCase			:     int         =      self.conv(a		)
								__UpperCamelCase			:     Any         =      self.batch_norm(a		)
								__UpperCamelCase			:     Union[str, Any]         =      self.activation(a		)

								return output




class 				lowerCamelCase__							(       nn.Module):




	'''simple docstring'''




	def __init__(      self	:List[str]  ,     a	:int  ,     a	:int  ,     a	:int		)	->				None:
								super().__init__()
								__UpperCamelCase			:     Optional[int]         =      [
								    nn.AdaptiveAvgPoolad(a		),
								    UperNetConvModule(a  ,     a  ,     kernel_size=1		),
								]
								for i, layer in enumerate(self.layers		):
															self.add_module(str(a		)  ,     a		)







	def      _lowerCamelCase       (      self	:Union[str, Any]  ,     a	:torch.Tensor		)	->				torch.Tensor:
								__UpperCamelCase			:     Tuple         =      input
								for layer in self.layers:
															__UpperCamelCase			:     Dict         =      layer(a		)
								return hidden_state




class 				lowerCamelCase__							(       nn.Module):




	'''simple docstring'''




	def __init__(      self	:Dict  ,     a	:Tuple[int, ...]  ,     a	:int  ,     a	:int  ,     a	:bool		)	->				None:
								super().__init__()
								__UpperCamelCase			:     Optional[int]         =      pool_scales
								__UpperCamelCase			:     Optional[Any]         =      align_corners
								__UpperCamelCase			:     List[str]         =      in_channels
								__UpperCamelCase			:     Union[str, Any]         =      channels
								__UpperCamelCase			:     Union[str, Any]         =      []
								for i, pool_scale in enumerate(a		):
															__UpperCamelCase			:     str         =      UperNetPyramidPoolingBlock(pool_scale=a  ,     in_channels=a  ,     channels=a		)
															self.blocks.append(a		)
															self.add_module(str(a		)  ,     a		)







	def      _lowerCamelCase       (      self	:List[str]  ,     a	:torch.Tensor		)	->				List[torch.Tensor]:
								__UpperCamelCase			:     Union[str, Any]         =      []
								for ppm in self.blocks:
															__UpperCamelCase			:     Union[str, Any]         =      ppm(a		)
															__UpperCamelCase			:     str         =      nn.functional.interpolate(
															    a  ,     size=x.size()[2:]  ,     mode="bilinear"  ,     align_corners=self.align_corners		)
															ppm_outs.append(a		)
								return ppm_outs




class 				lowerCamelCase__							(       nn.Module):




	'''simple docstring'''




	def __init__(      self	:List[Any]  ,     a	:Any  ,     a	:Optional[Any]		)	->				int:
								super().__init__()

								__UpperCamelCase			:     Optional[int]         =      config
								__UpperCamelCase			:     str         =      config.pool_scales  # e.g. (1, 2, 3, 6)
								__UpperCamelCase			:     Optional[int]         =      in_channels
								__UpperCamelCase			:     List[str]         =      config.hidden_size
								__UpperCamelCase			:     int         =      False
								__UpperCamelCase			:     str         =      nn.Convad(self.channels  ,     config.num_labels  ,     kernel_size=1		)

								# PSP Module
								__UpperCamelCase			:     List[Any]         =      UperNetPyramidPoolingModule(
								    self.pool_scales  ,     self.in_channels[-1]  ,     self.channels  ,     align_corners=self.align_corners  ,     )
								__UpperCamelCase			:     Tuple         =      UperNetConvModule(
								    self.in_channels[-1] + len(self.pool_scales		) * self.channels  ,     self.channels  ,     kernel_size=3  ,     padding=1  ,     )
								# FPN Module
								__UpperCamelCase			:     Any         =      nn.ModuleList()
								__UpperCamelCase			:     Union[str, Any]         =      nn.ModuleList()
								for in_channels in self.in_channels[:-1]:  # skip the top layer
															__UpperCamelCase			:     Tuple         =      UperNetConvModule(a  ,     self.channels  ,     kernel_size=1		)
															__UpperCamelCase			:     List[Any]         =      UperNetConvModule(self.channels  ,     self.channels  ,     kernel_size=3  ,     padding=1		)
															self.lateral_convs.append(a		)
															self.fpn_convs.append(a		)

								__UpperCamelCase			:     Union[str, Any]         =      UperNetConvModule(
								    len(self.in_channels		) * self.channels  ,     self.channels  ,     kernel_size=3  ,     padding=1  ,     )







	def      _lowerCamelCase       (      self	:Tuple		)	->				List[str]:
								self.apply(self._init_weights		)







	def      _lowerCamelCase       (      self	:str  ,     a	:int		)	->				Tuple:
								if isinstance(a  ,     nn.Convad		):
															module.weight.data.normal_(mean=0.0  ,     std=self.config.initializer_range		)
															if module.bias is not None:
																						module.bias.data.zero_()







	def      _lowerCamelCase       (      self	:List[str]  ,     a	:List[str]		)	->				int:
								__UpperCamelCase			:     Optional[int]         =      inputs[-1]
								__UpperCamelCase			:     Tuple         =      [x]
								psp_outs.extend(self.psp_modules(a		)		)
								__UpperCamelCase			:     List[str]         =      torch.cat(a  ,     dim=1		)
								__UpperCamelCase			:     Any         =      self.bottleneck(a		)

								return output







	def      _lowerCamelCase       (      self	:List[Any]  ,     a	:torch.Tensor		)	->				torch.Tensor:
								# build laterals
								__UpperCamelCase			:     List[str]         =      [lateral_conv(encoder_hidden_states[i]		) for i, lateral_conv in enumerate(self.lateral_convs		)]

								laterals.append(self.psp_forward(a		)		)

								# build top-down path
								__UpperCamelCase			:     str         =      len(a		)
								for i in range(used_backbone_levels - 1  ,     0  ,     -1		):
															__UpperCamelCase			:     str         =      laterals[i - 1].shape[2:]
															__UpperCamelCase			:     int         =      laterals[i - 1] + nn.functional.interpolate(
															    laterals[i]  ,     size=a  ,     mode="bilinear"  ,     align_corners=self.align_corners		)

								# build outputs
								__UpperCamelCase			:     int         =      [self.fpn_convs[i](laterals[i]		) for i in range(used_backbone_levels - 1		)]
								# append psp feature
								fpn_outs.append(laterals[-1]		)

								for i in range(used_backbone_levels - 1  ,     0  ,     -1		):
															__UpperCamelCase			:     Tuple         =      nn.functional.interpolate(
															    fpn_outs[i]  ,     size=fpn_outs[0].shape[2:]  ,     mode="bilinear"  ,     align_corners=self.align_corners		)
								__UpperCamelCase			:     Any         =      torch.cat(a  ,     dim=1		)
								__UpperCamelCase			:     int         =      self.fpn_bottleneck(a		)
								__UpperCamelCase			:     int         =      self.classifier(a		)

								return output




class 				lowerCamelCase__							(       nn.Module):




	'''simple docstring'''




	def __init__(      self	:Any  ,     a	:Any  ,     a	:int = 2  ,     a	:int = 3  ,     a	:Union[int, Tuple[int, int]] = 1		)	->				None:
								super().__init__()

								__UpperCamelCase			:     int         =      config
								__UpperCamelCase			:     Optional[Any]         =      config.auxiliary_in_channels
								__UpperCamelCase			:     Union[str, Any]         =      config.auxiliary_channels
								__UpperCamelCase			:     Optional[int]         =      config.auxiliary_num_convs
								__UpperCamelCase			:     Optional[Any]         =      config.auxiliary_concat_input
								__UpperCamelCase			:     str         =      in_index

								__UpperCamelCase			:     List[Any]         =      (kernel_size // 2) * dilation
								__UpperCamelCase			:     Any         =      []
								convs.append(
								    UperNetConvModule(
								        self.in_channels  ,     self.channels  ,     kernel_size=a  ,     padding=a  ,     dilation=a		)		)
								for i in range(self.num_convs - 1		):
															convs.append(
															    UperNetConvModule(
															        self.channels  ,     self.channels  ,     kernel_size=a  ,     padding=a  ,     dilation=a		)		)
								if self.num_convs == 0:
															__UpperCamelCase			:     Union[str, Any]         =      nn.Identity()
								else:
															__UpperCamelCase			:     Union[str, Any]         =      nn.Sequential(*a		)
								if self.concat_input:
															__UpperCamelCase			:     Any         =      UperNetConvModule(
															    self.in_channels + self.channels  ,     self.channels  ,     kernel_size=a  ,     padding=kernel_size // 2		)

								__UpperCamelCase			:     Tuple         =      nn.Convad(self.channels  ,     config.num_labels  ,     kernel_size=1		)







	def      _lowerCamelCase       (      self	:List[Any]		)	->				List[str]:
								self.apply(self._init_weights		)







	def      _lowerCamelCase       (      self	:Optional[int]  ,     a	:Dict		)	->				List[str]:
								if isinstance(a  ,     nn.Convad		):
															module.weight.data.normal_(mean=0.0  ,     std=self.config.initializer_range		)
															if module.bias is not None:
																						module.bias.data.zero_()







	def      _lowerCamelCase       (      self	:Union[str, Any]  ,     a	:torch.Tensor		)	->				torch.Tensor:
								# just take the relevant feature maps
								__UpperCamelCase			:     str         =      encoder_hidden_states[self.in_index]
								__UpperCamelCase			:     Optional[int]         =      self.convs(a		)
								if self.concat_input:
															__UpperCamelCase			:     int         =      self.conv_cat(torch.cat([hidden_states, output]  ,     dim=1		)		)
								__UpperCamelCase			:     str         =      self.classifier(a		)
								return output




class 				lowerCamelCase__							(       __lowercase):




	'''simple docstring'''




	_A			=  UperNetConfig
	_A			=  'pixel_values'
	_A			=  True







	def      _lowerCamelCase       (      self	:Tuple  ,     a	:List[Any]		)	->				Optional[Any]:
								if isinstance(a  ,     a		):
															module.backbone.init_weights()
															module.decode_head.init_weights()
															module.auxiliary_head.init_weights()







	def      _lowerCamelCase       (      self	:Dict		)	->				Any:
								self.backbone.init_weights()
								self.decode_head.init_weights()
								self.auxiliary_head.init_weights()







	def      _lowerCamelCase       (      self	:List[str]  ,     a	:List[Any]  ,     a	:Optional[Any]=False		)	->				Union[str, Any]:
								if isinstance(a  ,     a		):
															__UpperCamelCase			:     Tuple         =      value
lowercase						:      Dict									= R'\n    Parameters:\n    This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) sub-class. Use\n    it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and\n    behavior.\n        config ([`UperNetConfig`]): 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'

lowercase						:      Dict									= R'\n    Args:\n        pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):\n            Pixel values. Padding will be ignored by default should you provide it. Pixel values can be obtained using\n            [`AutoImageProcessor`]. See [`SegformerImageProcessor.__call__`] for details.\n        output_attentions (`bool`, *optional*):\n            Whether or not to return the attentions tensors of all attention layers in case the backbone has them. See\n            `attentions` under returned tensors for more detail.\n        output_hidden_states (`bool`, *optional*):\n            Whether or not to return the hidden states of all layers of the backbone. See `hidden_states` under\n            returned tensors for 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(
    'UperNet framework leveraging any vision backbone e.g. for ADE20k, CityScapes.'  ,		__lowercase  ,		)
class 				lowerCamelCase__							(       __lowercase):




	'''simple docstring'''




	def __init__(      self	:int  ,     a	:Tuple		)	->				List[str]:
								super().__init__(a		)

								__UpperCamelCase			:     Union[str, Any]         =      AutoBackbone.from_config(config.backbone_config		)

								# Semantic segmentation head(s)
								__UpperCamelCase			:     int         =      UperNetHead(a  ,     in_channels=self.backbone.channels		)
								__UpperCamelCase			:     Any         =      UperNetFCNHead(a		) if config.use_auxiliary_head else None

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







	@add_start_docstrings_to_model_forward(UPERNET_INPUTS_DOCSTRING.format("batch_size, sequence_length"		)		)
	@replace_return_docstrings(output_type=a  ,     config_class=_CONFIG_FOR_DOC		)
	def      _lowerCamelCase       (      self	:Any  ,     a	:Optional[torch.Tensor] = None  ,     a	:Optional[bool] = None  ,     a	:Optional[bool] = None  ,     a	:Optional[torch.Tensor] = None  ,     a	:Optional[bool] = None  ,     )	->				Union[tuple, SemanticSegmenterOutput]:
								__UpperCamelCase			:     Union[str, Any]         =      return_dict if return_dict is not None else self.config.use_return_dict
								__UpperCamelCase			:     Tuple         =      (
								    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
								)
								__UpperCamelCase			:     Union[str, Any]         =      output_attentions if output_attentions is not None else self.config.output_attentions

								__UpperCamelCase			:     int         =      self.backbone.forward_with_filtered_kwargs(
								    a  ,     output_hidden_states=a  ,     output_attentions=a		)
								__UpperCamelCase			:     Optional[Any]         =      outputs.feature_maps

								__UpperCamelCase			:     str         =      self.decode_head(a		)
								__UpperCamelCase			:     List[str]         =      nn.functional.interpolate(a  ,     size=pixel_values.shape[2:]  ,     mode="bilinear"  ,     align_corners=a		)

								__UpperCamelCase			:     Union[str, Any]         =      None
								if self.auxiliary_head is not None:
															__UpperCamelCase			:     Optional[Any]         =      self.auxiliary_head(a		)
															__UpperCamelCase			:     List[str]         =      nn.functional.interpolate(
															    a  ,     size=pixel_values.shape[2:]  ,     mode="bilinear"  ,     align_corners=a		)

								__UpperCamelCase			:     int         =      None
								if labels is not None:
															if self.config.num_labels == 1:
																						raise ValueError("The number of labels should be greater than one"		)
															else:
																						# compute weighted loss
																						__UpperCamelCase			:     Any         =      CrossEntropyLoss(ignore_index=self.config.loss_ignore_index		)
																						__UpperCamelCase			:     Optional[Any]         =      loss_fct(a  ,     a		)
																						__UpperCamelCase			:     Optional[int]         =      loss_fct(a  ,     a		)
																						__UpperCamelCase			:     Tuple         =      main_loss + self.config.auxiliary_loss_weight * auxiliary_loss

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

								return SemanticSegmenterOutput(
								    loss=a  ,     logits=a  ,     hidden_states=outputs.hidden_states  ,     attentions=outputs.attentions  ,     )

from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


lowercase						:      List[Any]									= {'configuration_swin': ['SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP', 'SwinConfig', 'SwinOnnxConfig']}


try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		lowercase						:      Dict									= [
		    'SWIN_PRETRAINED_MODEL_ARCHIVE_LIST',
		    'SwinForImageClassification',
		    'SwinForMaskedImageModeling',
		    'SwinModel',
		    'SwinPreTrainedModel',
		    'SwinBackbone',
		]

try:
		if not is_tf_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		lowercase						:      Optional[int]									= [
		    'TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST',
		    'TFSwinForImageClassification',
		    'TFSwinForMaskedImageModeling',
		    'TFSwinModel',
		    'TFSwinPreTrainedModel',
		]

if TYPE_CHECKING:
		from .configuration_swin import SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP, SwinConfig, SwinOnnxConfig

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_swin import (
				    SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
				    SwinBackbone,
				    SwinForImageClassification,
				    SwinForMaskedImageModeling,
				    SwinModel,
				    SwinPreTrainedModel,
				)

		try:
				if not is_tf_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_tf_swin import (
				    TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
				    TFSwinForImageClassification,
				    TFSwinForMaskedImageModeling,
				    TFSwinModel,
				    TFSwinPreTrainedModel,
				)

else:
		import sys

		lowercase						:      Optional[Any]									= _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)