





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


UpperCamelCase__											= [
    "openmmlab/upernet-convnext-tiny",
    # See all UperNet models at https://huggingface.co/models?filter=upernet
]

# General docstring
UpperCamelCase__											= "UperNetConfig"

class        __SCREAMING_SNAKE_CASE					(     nn.Module       ):






							def __init__(						self  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase = 0  , __lowerCAmelCase = False  , __lowerCAmelCase = 1  , ):
														super().__init__()
														UpperCamelCase__				     =			nn.Convad(
														    in_channels=__lowerCAmelCase  , out_channels=__lowerCAmelCase  , kernel_size=__lowerCAmelCase  , padding=__lowerCAmelCase  , bias=__lowerCAmelCase  , dilation=__lowerCAmelCase  , )
														UpperCamelCase__				     =			nn.BatchNormad(__lowerCAmelCase  )
														UpperCamelCase__				     =			nn.ReLU()







							def 				_lowerCamelCase		(						self  , __lowerCAmelCase  ):
														UpperCamelCase__				     =			self.conv(__lowerCAmelCase  )
														UpperCamelCase__				     =			self.batch_norm(__lowerCAmelCase  )
														UpperCamelCase__				     =			self.activation(__lowerCAmelCase  )

														return output






class        __SCREAMING_SNAKE_CASE					(     nn.Module       ):






							def __init__(						self  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  ):
														super().__init__()
														UpperCamelCase__				     =			[
														    nn.AdaptiveAvgPoolad(__lowerCAmelCase  ),
														    UperNetConvModule(__lowerCAmelCase  , __lowerCAmelCase  , kernel_size=1  ),
														]
														for i, layer in enumerate(self.layers  ):
																					self.add_module(str(__lowerCAmelCase  )  , __lowerCAmelCase  )







							def 				_lowerCamelCase		(						self  , __lowerCAmelCase  ):
														UpperCamelCase__				     =			input
														for layer in self.layers:
																					UpperCamelCase__				     =			layer(__lowerCAmelCase  )
														return hidden_state






class        __SCREAMING_SNAKE_CASE					(     nn.Module       ):






							def __init__(						self  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  ):
														super().__init__()
														UpperCamelCase__				     =			pool_scales
														UpperCamelCase__				     =			align_corners
														UpperCamelCase__				     =			in_channels
														UpperCamelCase__				     =			channels
														UpperCamelCase__				     =			[]
														for i, pool_scale in enumerate(__lowerCAmelCase  ):
																					UpperCamelCase__				     =			UperNetPyramidPoolingBlock(pool_scale=__lowerCAmelCase  , in_channels=__lowerCAmelCase  , channels=__lowerCAmelCase  )
																					self.blocks.append(__lowerCAmelCase  )
																					self.add_module(str(__lowerCAmelCase  )  , __lowerCAmelCase  )







							def 				_lowerCamelCase		(						self  , __lowerCAmelCase  ):
														UpperCamelCase__				     =			[]
														for ppm in self.blocks:
																					UpperCamelCase__				     =			ppm(__lowerCAmelCase  )
																					UpperCamelCase__				     =			nn.functional.interpolate(
																					    __lowerCAmelCase  , size=x.size()[2:]  , mode="""bilinear"""  , align_corners=self.align_corners  )
																					ppm_outs.append(__lowerCAmelCase  )
														return ppm_outs






class        __SCREAMING_SNAKE_CASE					(     nn.Module       ):






							def __init__(						self  , __lowerCAmelCase  , __lowerCAmelCase  ):
														super().__init__()

														UpperCamelCase__				     =			config
														UpperCamelCase__				     =			config.pool_scales  # e.g. (1, 2, 3, 6)
														UpperCamelCase__				     =			in_channels
														UpperCamelCase__				     =			config.hidden_size
														UpperCamelCase__				     =			False
														UpperCamelCase__				     =			nn.Convad(self.channels  , config.num_labels  , kernel_size=1  )

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

														UpperCamelCase__				     =			UperNetConvModule(
														    len(self.in_channels  ) * self.channels  , self.channels  , kernel_size=3  , padding=1  , )






							def 				_lowerCamelCase		(						self  ):
														self.apply(self._init_weights  )






							def 				_lowerCamelCase		(						self  , __lowerCAmelCase  ):
														if isinstance(__lowerCAmelCase  , 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  , __lowerCAmelCase  ):
														UpperCamelCase__				     =			inputs[-1]
														UpperCamelCase__				     =			[x]
														psp_outs.extend(self.psp_modules(__lowerCAmelCase  )  )
														UpperCamelCase__				     =			torch.cat(__lowerCAmelCase  , dim=1  )
														UpperCamelCase__				     =			self.bottleneck(__lowerCAmelCase  )

														return output







							def 				_lowerCamelCase		(						self  , __lowerCAmelCase  ):
														# build laterals
														UpperCamelCase__				     =			[lateral_conv(encoder_hidden_states[i]  ) for i, lateral_conv in enumerate(self.lateral_convs  )]

														laterals.append(self.psp_forward(__lowerCAmelCase  )  )

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

														# build outputs
														UpperCamelCase__				     =			[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__				     =			nn.functional.interpolate(
																					    fpn_outs[i]  , size=fpn_outs[0].shape[2:]  , mode="""bilinear"""  , align_corners=self.align_corners  )
														UpperCamelCase__				     =			torch.cat(__lowerCAmelCase  , dim=1  )
														UpperCamelCase__				     =			self.fpn_bottleneck(__lowerCAmelCase  )
														UpperCamelCase__				     =			self.classifier(__lowerCAmelCase  )

														return output






class        __SCREAMING_SNAKE_CASE					(     nn.Module       ):






							def __init__(						self  , __lowerCAmelCase  , __lowerCAmelCase = 2  , __lowerCAmelCase = 3  , __lowerCAmelCase = 1  ):
														super().__init__()

														UpperCamelCase__				     =			config
														UpperCamelCase__				     =			config.auxiliary_in_channels
														UpperCamelCase__				     =			config.auxiliary_channels
														UpperCamelCase__				     =			config.auxiliary_num_convs
														UpperCamelCase__				     =			config.auxiliary_concat_input
														UpperCamelCase__				     =			in_index

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

														UpperCamelCase__				     =			nn.Convad(self.channels  , config.num_labels  , kernel_size=1  )






							def 				_lowerCamelCase		(						self  ):
														self.apply(self._init_weights  )






							def 				_lowerCamelCase		(						self  , __lowerCAmelCase  ):
														if isinstance(__lowerCAmelCase  , 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  , __lowerCAmelCase  ):
														# just take the relevant feature maps
														UpperCamelCase__				     =			encoder_hidden_states[self.in_index]
														UpperCamelCase__				     =			self.convs(__lowerCAmelCase  )
														if self.concat_input:
																					UpperCamelCase__				     =			self.conv_cat(torch.cat([hidden_states, output]  , dim=1  )  )
														UpperCamelCase__				     =			self.classifier(__lowerCAmelCase  )
														return output






class        __SCREAMING_SNAKE_CASE					(     _a       ):
							snake_case     :      int						     =       UperNetConfig
							snake_case     :      Any						     =       """pixel_values"""
							snake_case     :      Dict						     =       True






							def 				_lowerCamelCase		(						self  , __lowerCAmelCase  ):
														if isinstance(__lowerCAmelCase  , __lowerCAmelCase  ):
																					module.backbone.init_weights()
																					module.decode_head.init_weights()
																					module.auxiliary_head.init_weights()






							def 				_lowerCamelCase		(						self  ):
														self.backbone.init_weights()
														self.decode_head.init_weights()
														self.auxiliary_head.init_weights()







							def 				_lowerCamelCase		(						self  , __lowerCAmelCase  , __lowerCAmelCase=False  ):
														if isinstance(__lowerCAmelCase  , __lowerCAmelCase  ):
																					UpperCamelCase__				     =			value






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

UpperCamelCase__											= 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."""   ,		_a   ,		)
class        __SCREAMING_SNAKE_CASE					(     _a       ):






							def __init__(						self  , __lowerCAmelCase  ):
														super().__init__(__lowerCAmelCase  )

														UpperCamelCase__				     =			AutoBackbone.from_config(config.backbone_config  )

														# Semantic segmentation head(s)
														UpperCamelCase__				     =			UperNetHead(__lowerCAmelCase  , in_channels=self.backbone.channels  )
														UpperCamelCase__				     =			UperNetFCNHead(__lowerCAmelCase  ) 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=__lowerCAmelCase  , config_class=_CONFIG_FOR_DOC  )
							def 				_lowerCamelCase		(						self  , __lowerCAmelCase = None  , __lowerCAmelCase = None  , __lowerCAmelCase = None  , __lowerCAmelCase = None  , __lowerCAmelCase = None  , ):
														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__				     =			output_attentions if output_attentions is not None else self.config.output_attentions

														UpperCamelCase__				     =			self.backbone.forward_with_filtered_kwargs(
														    __lowerCAmelCase  , output_hidden_states=__lowerCAmelCase  , output_attentions=__lowerCAmelCase  )
														UpperCamelCase__				     =			outputs.feature_maps

														UpperCamelCase__				     =			self.decode_head(__lowerCAmelCase  )
														UpperCamelCase__				     =			nn.functional.interpolate(__lowerCAmelCase  , size=pixel_values.shape[2:]  , mode="""bilinear"""  , align_corners=__lowerCAmelCase  )

														UpperCamelCase__				     =			None
														if self.auxiliary_head is not None:
																					UpperCamelCase__				     =			self.auxiliary_head(__lowerCAmelCase  )
																					UpperCamelCase__				     =			nn.functional.interpolate(
																					    __lowerCAmelCase  , size=pixel_values.shape[2:]  , mode="""bilinear"""  , align_corners=__lowerCAmelCase  )

														UpperCamelCase__				     =			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__				     =			CrossEntropyLoss(ignore_index=self.config.loss_ignore_index  )
																												UpperCamelCase__				     =			loss_fct(__lowerCAmelCase  , __lowerCAmelCase  )
																												UpperCamelCase__				     =			loss_fct(__lowerCAmelCase  , __lowerCAmelCase  )
																												UpperCamelCase__				     =			main_loss + self.config.auxiliary_loss_weight * auxiliary_loss

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

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











from typing import TYPE_CHECKING

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


UpperCamelCase__											= {
    "configuration_pix2struct": [
        "PIX2STRUCT_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "Pix2StructConfig",
        "Pix2StructTextConfig",
        "Pix2StructVisionConfig",
    ],
    "processing_pix2struct": ["Pix2StructProcessor"],
}

try:
					if not is_vision_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					UpperCamelCase__											= ["Pix2StructImageProcessor"]


try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					UpperCamelCase__											= [
					    "PIX2STRUCT_PRETRAINED_MODEL_ARCHIVE_LIST",
					    "Pix2StructPreTrainedModel",
					    "Pix2StructForConditionalGeneration",
					    "Pix2StructVisionModel",
					    "Pix2StructTextModel",
					]

if TYPE_CHECKING:
					from .configuration_pixastruct import (
					    PIX2STRUCT_PRETRAINED_CONFIG_ARCHIVE_MAP,
					    PixaStructConfig,
					    PixaStructTextConfig,
					    PixaStructVisionConfig,
					)
					from .processing_pixastruct import PixaStructProcessor

					try:
										if not is_vision_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .image_processing_pixastruct import PixaStructImageProcessor

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_pixastruct import (
										    PIX2STRUCT_PRETRAINED_MODEL_ARCHIVE_LIST,
										    PixaStructForConditionalGeneration,
										    PixaStructPreTrainedModel,
										    PixaStructTextModel,
										    PixaStructVisionModel,
										)

else:
					import sys

					UpperCamelCase__											= _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)




