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


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

# General docstring
_lowerCamelCase					:   Optional[Any]							=		'UperNetConfig'


class 						lowercase    (     nn.Module     ):




							def __init__(						self   :					Any	,							_UpperCamelCase   :					int	,							_UpperCamelCase   :					int	,							_UpperCamelCase   :					Union[int, Tuple[int, int]]	,							_UpperCamelCase   :					Union[int, Tuple[int, int], str] = 0	,							_UpperCamelCase   :					bool = False	,							_UpperCamelCase   :					Union[int, Tuple[int, int]] = 1	,							)					->				str:



												'''simple docstring'''

												super().__init__()
												SCREAMING_SNAKE_CASE    			=       nn.Convad(
												    in_channels=UpperCamelCase__	,							out_channels=UpperCamelCase__	,							kernel_size=UpperCamelCase__	,							padding=UpperCamelCase__	,							bias=UpperCamelCase__	,							dilation=UpperCamelCase__	,							)
												SCREAMING_SNAKE_CASE    			=       nn.BatchNormad(UpperCamelCase__      )
												SCREAMING_SNAKE_CASE    			=       nn.ReLU()





							def 	__snake_case(						self   :					Tuple	,							_UpperCamelCase   :					torch.Tensor      )					->				Dict:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       self.conv(UpperCamelCase__      )
												SCREAMING_SNAKE_CASE    			=       self.batch_norm(UpperCamelCase__      )
												SCREAMING_SNAKE_CASE    			=       self.activation(UpperCamelCase__      )

												return output



class 						lowercase    (     nn.Module     ):




							def __init__(						self   :					Optional[int]	,							_UpperCamelCase   :					int	,							_UpperCamelCase   :					int	,							_UpperCamelCase   :					int      )					->				Any:



												'''simple docstring'''

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





							def 	__snake_case(						self   :					List[Any]	,							_UpperCamelCase   :					torch.Tensor      )					->				Optional[Any]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       input
												for layer in self.layers:
																	SCREAMING_SNAKE_CASE    			=       layer(UpperCamelCase__      )
												return hidden_state



class 						lowercase    (     nn.Module     ):




							def __init__(						self   :					str	,							_UpperCamelCase   :					Tuple[int, ...]	,							_UpperCamelCase   :					int	,							_UpperCamelCase   :					int	,							_UpperCamelCase   :					bool      )					->				Tuple:



												'''simple docstring'''

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





							def 	__snake_case(						self   :					Dict	,							_UpperCamelCase   :					torch.Tensor      )					->				str:



												'''simple docstring'''

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



class 						lowercase    (     nn.Module     ):




							def __init__(						self   :					Union[str, Any]	,							_UpperCamelCase   :					Dict	,							_UpperCamelCase   :					Tuple      )					->				Optional[int]:



												'''simple docstring'''

												super().__init__()

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

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

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




							def 	__snake_case(						self   :					Optional[int]      )					->				Union[str, Any]:



												'''simple docstring'''

												self.apply(self._init_weights      )




							def 	__snake_case(						self   :					Union[str, Any]	,							_UpperCamelCase   :					Tuple      )					->				Dict:



												'''simple docstring'''

												if isinstance(UpperCamelCase__	,							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 	__snake_case(						self   :					Any	,							_UpperCamelCase   :					Tuple      )					->				str:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       inputs[-1]
												SCREAMING_SNAKE_CASE    			=       [x]
												psp_outs.extend(self.psp_modules(UpperCamelCase__      )      )
												SCREAMING_SNAKE_CASE    			=       torch.cat(UpperCamelCase__	,							dim=1      )
												SCREAMING_SNAKE_CASE    			=       self.bottleneck(UpperCamelCase__      )

												return output





							def 	__snake_case(						self   :					List[Any]	,							_UpperCamelCase   :					torch.Tensor      )					->				str:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       [lateral_conv(encoder_hidden_states[i]      ) for i, lateral_conv in enumerate(self.lateral_convs      )]

												laterals.append(self.psp_forward(UpperCamelCase__      )      )

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

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

												return output



class 						lowercase    (     nn.Module     ):




							def __init__(						self   :					List[Any]	,							_UpperCamelCase   :					Union[str, Any]	,							_UpperCamelCase   :					int = 2	,							_UpperCamelCase   :					int = 3	,							_UpperCamelCase   :					Union[int, Tuple[int, int]] = 1      )					->				Optional[int]:



												'''simple docstring'''

												super().__init__()

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

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

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




							def 	__snake_case(						self   :					List[Any]      )					->				Optional[int]:



												'''simple docstring'''

												self.apply(self._init_weights      )




							def 	__snake_case(						self   :					Optional[Any]	,							_UpperCamelCase   :					Tuple      )					->				Any:



												'''simple docstring'''

												if isinstance(UpperCamelCase__	,							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 	__snake_case(						self   :					Dict	,							_UpperCamelCase   :					torch.Tensor      )					->				Optional[Any]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       encoder_hidden_states[self.in_index]
												SCREAMING_SNAKE_CASE    			=       self.convs(UpperCamelCase__      )
												if self.concat_input:
																	SCREAMING_SNAKE_CASE    			=       self.conv_cat(torch.cat([hidden_states, output]	,							dim=1      )      )
												SCREAMING_SNAKE_CASE    			=       self.classifier(UpperCamelCase__      )
												return output



class 						lowercase    (     UpperCamelCase_     ):
							lowercase__						:       Optional[Any]								=							UperNetConfig
							lowercase__						:       Optional[Any]								=							"""pixel_values"""
							lowercase__						:       int								=							True




							def 	__snake_case(						self   :					Optional[int]	,							_UpperCamelCase   :					Dict      )					->				int:



												'''simple docstring'''

												if isinstance(UpperCamelCase__	,							UpperCamelCase__      ):
																	module.backbone.init_weights()
																	module.decode_head.init_weights()
																	module.auxiliary_head.init_weights()




							def 	__snake_case(						self   :					List[str]      )					->				Tuple:



												'''simple docstring'''

												self.backbone.init_weights()
												self.decode_head.init_weights()
												self.auxiliary_head.init_weights()





							def 	__snake_case(						self   :					List[Any]	,							_UpperCamelCase   :					Any	,							_UpperCamelCase   :					int=False      )					->				Tuple:



												'''simple docstring'''

												if isinstance(UpperCamelCase__	,							UpperCamelCase__      ):
																	SCREAMING_SNAKE_CASE    			=       value



_lowerCamelCase					:   str							=		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'

_lowerCamelCase					:   int							=		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."""				,       UpperCamelCase_				,       )
class 						lowercase    (     UpperCamelCase_     ):




							def __init__(						self   :					Any	,							_UpperCamelCase   :					List[str]      )					->				int:



												'''simple docstring'''

												super().__init__(UpperCamelCase__      )

												SCREAMING_SNAKE_CASE    			=       AutoBackbone.from_config(config.backbone_config      )

												# Semantic segmentation head(s)
												SCREAMING_SNAKE_CASE    			=       UperNetHead(UpperCamelCase__	,							in_channels=self.backbone.channels      )
												SCREAMING_SNAKE_CASE    			=       UperNetFCNHead(UpperCamelCase__      ) 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=UpperCamelCase__	,							config_class=_CONFIG_FOR_DOC      )
							def 	__snake_case(						self   :					List[str]	,							_UpperCamelCase   :					Optional[torch.Tensor] = None	,							_UpperCamelCase   :					Optional[bool] = None	,							_UpperCamelCase   :					Optional[bool] = None	,							_UpperCamelCase   :					Optional[torch.Tensor] = None	,							_UpperCamelCase   :					Optional[bool] = None	,							)					->				int:



												'''simple docstring'''

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

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

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

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

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

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

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





import os
import tempfile
import unittest

from transformers.models.marian.convert_marian_tatoeba_to_pytorch import DEFAULT_REPO, TatoebaConverter
from transformers.testing_utils import slow
from transformers.utils import cached_property


@unittest.skipUnless(os.path.exists(a     )				,       """Tatoeba directory does not exist."""     )
class 						lowercase    (     unittest.TestCase     ):




							@cached_property
							def 	__snake_case(						self   :					int      )					->				List[Any]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       tempfile.mkdtemp()
												return TatoebaConverter(save_dir=_UpperCamelCase      )




							@slow
							def 	__snake_case(						self   :					Tuple      )					->				List[Any]:



												'''simple docstring'''

												self.resolver.convert_models(["heb-eng"]      )





							@slow
							def 	__snake_case(						self   :					Any      )					->				Optional[int]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE			,   SCREAMING_SNAKE_CASE    			=       self.resolver.write_model_card("opus-mt-he-en"	,							dry_run=_UpperCamelCase      )
												assert mmeta["long_pair"] == "heb-eng"




