


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


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

# General docstring
_snake_case	:						Dict         =							"UperNetConfig"

class 							a						(nn.Module ):




							"""simple docstring"""


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






							def        __snake_case   (				self			:    List[Any]       ,      lowerCamelCase			:    torch.Tensor							)      ->       torch.Tensor:
														__snake_case						:     Dict									=  self.conv(lowerCamelCase							)
														__snake_case						:     int									=  self.batch_norm(lowerCamelCase							)
														__snake_case						:     Optional[Any]									=  self.activation(lowerCamelCase							)

														return output

class 							a						(nn.Module ):




							"""simple docstring"""


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






							def        __snake_case   (				self			:    Dict       ,      lowerCamelCase			:    torch.Tensor							)      ->       torch.Tensor:
														__snake_case						:     List[str]									=  input
														for layer in self.layers:
																					__snake_case						:     Tuple									=  layer(lowerCamelCase							)
														return hidden_state

class 							a						(nn.Module ):




							"""simple docstring"""


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






							def        __snake_case   (				self			:    int       ,      lowerCamelCase			:    torch.Tensor							)      ->       List[torch.Tensor]:
														__snake_case						:     Tuple									=  []
														for ppm in self.blocks:
																					__snake_case						:     Any									=  ppm(lowerCamelCase							)
																					__snake_case						:     List[Any]									=  nn.functional.interpolate(
																					    lowerCamelCase       ,      size=x.size()[2:]       ,      mode="bilinear"       ,      align_corners=self.align_corners							)
																					ppm_outs.append(lowerCamelCase							)
														return ppm_outs

class 							a						(nn.Module ):




							"""simple docstring"""


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

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

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

														__snake_case						:     int									=  UperNetConvModule(
														    len(self.in_channels							) * self.channels       ,      self.channels       ,      kernel_size=3       ,      padding=1       ,      )

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

							def        __snake_case   (				self			:    Tuple       ,      lowerCamelCase			:    List[Any]							)      ->       str:
														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        __snake_case   (				self			:    List[Any]       ,      lowerCamelCase			:    Tuple							)      ->       Optional[int]:
														__snake_case						:     str									=  inputs[-1]
														__snake_case						:     int									=  [x]
														psp_outs.extend(self.psp_modules(lowerCamelCase							)							)
														__snake_case						:     Tuple									=  torch.cat(lowerCamelCase       ,      dim=1							)
														__snake_case						:     Union[str, Any]									=  self.bottleneck(lowerCamelCase							)

														return output






							def        __snake_case   (				self			:    int       ,      lowerCamelCase			:    torch.Tensor							)      ->       torch.Tensor:
														# build laterals
														__snake_case						:     Any									=  [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
														__snake_case						:     Dict									=  len(lowerCamelCase							)
														for i in range(used_backbone_levels - 1       ,      0       ,      -1							):
																					__snake_case						:     Union[str, Any]									=  laterals[i - 1].shape[2:]
																					__snake_case						:     Optional[int]									=  laterals[i - 1] + nn.functional.interpolate(
																					    laterals[i]       ,      size=lowerCamelCase       ,      mode="bilinear"       ,      align_corners=self.align_corners							)

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

														return output

class 							a						(nn.Module ):




							"""simple docstring"""


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

														__snake_case						:     List[Any]									=  config
														__snake_case						:     List[str]									=  config.auxiliary_in_channels
														__snake_case						:     List[Any]									=  config.auxiliary_channels
														__snake_case						:     Tuple									=  config.auxiliary_num_convs
														__snake_case						:     int									=  config.auxiliary_concat_input
														__snake_case						:     Optional[int]									=  in_index

														__snake_case						:     Tuple									=  (kernel_size // 2) * dilation
														__snake_case						:     Optional[int]									=  []
														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:
																					__snake_case						:     Union[str, Any]									=  nn.Identity()
														else:
																					__snake_case						:     Any									=  nn.Sequential(*lowerCamelCase							)
														if self.concat_input:
																					__snake_case						:     int									=  UperNetConvModule(
																					    self.in_channels + self.channels       ,      self.channels       ,      kernel_size=lowerCamelCase       ,      padding=kernel_size // 2							)

														__snake_case						:     Optional[Any]									=  nn.Convad(self.channels       ,      config.num_labels       ,      kernel_size=1							)

							def        __snake_case   (				self			:    Dict							)      ->       Optional[Any]:
														self.apply(self._init_weights							)

							def        __snake_case   (				self			:    Tuple       ,      lowerCamelCase			:    Tuple							)      ->       Optional[int]:
														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        __snake_case   (				self			:    Optional[int]       ,      lowerCamelCase			:    torch.Tensor							)      ->       torch.Tensor:
														# just take the relevant feature maps
														__snake_case						:     List[str]									=  encoder_hidden_states[self.in_index]
														__snake_case						:     Optional[Any]									=  self.convs(lowerCamelCase							)
														if self.concat_input:
																					__snake_case						:     Optional[Any]									=  self.conv_cat(torch.cat([hidden_states, output]       ,      dim=1							)							)
														__snake_case						:     Union[str, Any]									=  self.classifier(lowerCamelCase							)
														return output

class 							a						(_lowerCAmelCase ):




							"""simple docstring"""


							__UpperCAmelCase       :				Optional[Any]	    =    UperNetConfig
							__UpperCAmelCase       :				int	    =    "pixel_values"
							__UpperCAmelCase       :				str	    =    True

							def        __snake_case   (				self			:    Union[str, Any]       ,      lowerCamelCase			:    List[Any]							)      ->       List[Any]:
														if isinstance(lowerCamelCase       ,      lowerCamelCase							):
																					module.backbone.init_weights()
																					module.decode_head.init_weights()
																					module.auxiliary_head.init_weights()

							def        __snake_case   (				self			:    Optional[Any]							)      ->       List[str]:
														self.backbone.init_weights()
														self.decode_head.init_weights()
														self.auxiliary_head.init_weights()






							def        __snake_case   (				self			:    List[Any]       ,      lowerCamelCase			:    Any       ,      lowerCamelCase			:    Optional[Any]=False							)      ->       Dict:
														if isinstance(lowerCamelCase       ,      lowerCamelCase							):
																					__snake_case						:     Union[str, Any]									=  value
_snake_case	:						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"

_snake_case	:						Tuple         =							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."	,							_lowerCAmelCase	,							)
class 							a						(_lowerCAmelCase ):




							"""simple docstring"""


							def __init__(				self			:    Dict       ,      lowerCamelCase			:    int							)      ->       Optional[int]:
														super().__init__(lowerCamelCase							)

														__snake_case						:     Any									=  AutoBackbone.from_config(config.backbone_config							)

														# Semantic segmentation head(s)
														__snake_case						:     Union[str, Any]									=  UperNetHead(lowerCamelCase       ,      in_channels=self.backbone.channels							)
														__snake_case						:     Any									=  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        __snake_case   (				self			:    Union[str, Any]       ,      lowerCamelCase			:    Optional[torch.Tensor] = None       ,      lowerCamelCase			:    Optional[bool] = None       ,      lowerCamelCase			:    Optional[bool] = None       ,      lowerCamelCase			:    Optional[torch.Tensor] = None       ,      lowerCamelCase			:    Optional[bool] = None       ,      )      ->       Union[tuple, SemanticSegmenterOutput]:
														__snake_case						:     Any									=  return_dict if return_dict is not None else self.config.use_return_dict
														__snake_case						:     int									=  (
														    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
														)
														__snake_case						:     str									=  output_attentions if output_attentions is not None else self.config.output_attentions

														__snake_case						:     Tuple									=  self.backbone.forward_with_filtered_kwargs(
														    lowerCamelCase       ,      output_hidden_states=lowerCamelCase       ,      output_attentions=lowerCamelCase							)
														__snake_case						:     List[Any]									=  outputs.feature_maps

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

														__snake_case						:     Optional[int]									=  None
														if self.auxiliary_head is not None:
																					__snake_case						:     Dict									=  self.auxiliary_head(lowerCamelCase							)
																					__snake_case						:     Dict									=  nn.functional.interpolate(
																					    lowerCamelCase       ,      size=pixel_values.shape[2:]       ,      mode="bilinear"       ,      align_corners=lowerCamelCase							)

														__snake_case						:     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
																												__snake_case						:     Any									=  CrossEntropyLoss(ignore_index=self.config.loss_ignore_index							)
																												__snake_case						:     Union[str, Any]									=  loss_fct(lowerCamelCase       ,      lowerCamelCase							)
																												__snake_case						:     Optional[Any]									=  loss_fct(lowerCamelCase       ,      lowerCamelCase							)
																												__snake_case						:     Optional[Any]									=  main_loss + self.config.auxiliary_loss_weight * auxiliary_loss

														if not return_dict:
																					if output_hidden_states:
																												__snake_case						:     Any									=  (logits,) + outputs[1:]
																					else:
																												__snake_case						:     str									=  (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       ,      )









'''simple docstring'''

def 				snake_case       (  a_				:			str     , a_				:			Optional[int]						)							->					Any:





      """simple docstring"""

      UpperCamelCase_					: Tuple            =				(boundary[1] - boundary[0]) / steps
      UpperCamelCase_					: Dict            =				boundary[0]
      UpperCamelCase_					: Any            =				boundary[1]
      UpperCamelCase_					: Union[str, Any]            =				make_points(a_     , a_     , a_						)
      UpperCamelCase_					: Any            =				0.0
      y += (h / 2.0) * f(a_						)
      for i in x_i:
            # print(i)
            y += h * f(a_						)
      y += (h / 2.0) * f(a_						)
      return y



def 				snake_case       (  a_				:			Tuple     , a_				:			Any     , a_				:			Tuple						)							->					Tuple:





      """simple docstring"""

      UpperCamelCase_					: Optional[int]            =				a + h
      while x < (b - h):
            yield x
            UpperCamelCase_					: List[str]            =				x + h



def 				snake_case       (  a_				:			List[str]						)							->					Tuple:  # enter your function here





      """simple docstring"""

      UpperCamelCase_					: int            =				(x - 0) * (x - 0)
      return y



def 				snake_case       (  )							->					Dict:





      """simple docstring"""

      UpperCamelCase_					: Optional[Any]            =				0.0  # Lower bound of integration
      UpperCamelCase_					: Optional[int]            =				1.0  # Upper bound of integration
      UpperCamelCase_					: Optional[Any]            =				10.0  # define number of steps or resolution
      UpperCamelCase_					: Optional[Any]            =				[a, b]  # define boundary of integration
      UpperCamelCase_					: Any            =				method_a(a_     , a_						)
      print(f"y = {y}"						)


if __name__ == "__main__":
      main()






