





# DISCLAIMER: This code is strongly influenced by https://github.com/pesser/pytorch_diffusion
# and https://github.com/hojonathanho/diffusion
import math
from dataclasses import dataclass
from typing import List, Optional, Tuple, Union

import numpy as np
import torch

from diffusers.configuration_utils import ConfigMixin, register_to_config
from diffusers.schedulers.scheduling_utils import SchedulerMixin
from diffusers.utils import BaseOutput, deprecate

@dataclass
# Copied from diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput with DDPM->DDIM
class     __SCREAMING_SNAKE_CASE   (       __UpperCamelCase    ):
       snake_case       : torch.FloatTensor
       snake_case       : Optional[torch.FloatTensor]         =    None






def       _UpperCamelCase       (a__				:Union[str, Any]				,     a__				:int=0.999				,     a__				:List[str]="cosine"				,     ):






       """simple docstring"""





       if alpha_transform_type == "cosine":

              def alpha_bar_fn(a__				:Dict    ):
                     return math.cos((t + 0.008) / 1.008 * math.pi / 2    ) ** 2

       elif alpha_transform_type == "exp":

              def alpha_bar_fn(a__				:int    ):
                     return math.exp(t * -12.0    )

       else:
              raise ValueError(f"""Unsupported alpha_tranform_type: {alpha_transform_type}"""    )

       UpperCamelCase__			       =     []
       for i in range(__SCREAMING_SNAKE_CASE    ):
              UpperCamelCase__			       =     i / num_diffusion_timesteps
              UpperCamelCase__			       =     (i + 1) / num_diffusion_timesteps
              betas.append(min(1 - alpha_bar_fn(__SCREAMING_SNAKE_CASE    ) / alpha_bar_fn(__SCREAMING_SNAKE_CASE    )				,     __SCREAMING_SNAKE_CASE    )    )
       return torch.tensor(__SCREAMING_SNAKE_CASE				,     dtype=torch.floataa    )

class     __SCREAMING_SNAKE_CASE   (       __UpperCamelCase				,						__UpperCamelCase    ):
       snake_case       : Any         =    1






       @register_to_config
       def __init__(  self					,	__lowerCAmelCase = 1000					,	__lowerCAmelCase = 0.0001					,	__lowerCAmelCase = 0.02					,	__lowerCAmelCase = "linear"					,	__lowerCAmelCase = None					,	__lowerCAmelCase = True					,	__lowerCAmelCase = True					,	__lowerCAmelCase = 0					,	__lowerCAmelCase = "epsilon"					,	__lowerCAmelCase = 1.0					,	**__lowerCAmelCase					,	):
              if kwargs.get("""set_alpha_to_one"""					,	_lowerCAmelCase					) is not None:
                     UpperCamelCase__			       =     (
                         """The `set_alpha_to_one` argument is deprecated. Please use `set_alpha_to_zero` instead."""
                     )
                     deprecate("""set_alpha_to_one"""					,	"""1.0.0"""					,	_lowerCAmelCase					,	standard_warn=_lowerCAmelCase					)
                     UpperCamelCase__			       =     kwargs["""set_alpha_to_one"""]
              if trained_betas is not None:
                     UpperCamelCase__			       =     torch.tensor(_lowerCAmelCase					,	dtype=torch.floataa					)
              elif beta_schedule == "linear":
                     UpperCamelCase__			       =     torch.linspace(_lowerCAmelCase					,	_lowerCAmelCase					,	_lowerCAmelCase					,	dtype=torch.floataa					)
              elif beta_schedule == "scaled_linear":
                     # this schedule is very specific to the latent diffusion model.
                     UpperCamelCase__			       =     (
                         torch.linspace(beta_start**0.5					,	beta_end**0.5					,	_lowerCAmelCase					,	dtype=torch.floataa					) ** 2
                     )
              elif beta_schedule == "squaredcos_cap_v2":
                     # Glide cosine schedule
                     UpperCamelCase__			       =     betas_for_alpha_bar(_lowerCAmelCase					)
              else:
                     raise NotImplementedError(f"""{beta_schedule} does is not implemented for {self.__class__}"""					)

              UpperCamelCase__			       =     1.0 - self.betas
              UpperCamelCase__			       =     torch.cumprod(self.alphas					,	dim=0					)

              # At every step in inverted ddim, we are looking into the next alphas_cumprod
              # For the final step, there is no next alphas_cumprod, and the index is out of bounds
              # `set_alpha_to_zero` decides whether we set this parameter simply to zero
              # in this case, self.step() just output the predicted noise
              # or whether we use the final alpha of the "non-previous" one.
              UpperCamelCase__			       =     torch.tensor(0.0					) if set_alpha_to_zero else self.alphas_cumprod[-1]

              # standard deviation of the initial noise distribution
              UpperCamelCase__			       =     1.0

              # setable values
              UpperCamelCase__			       =     None
              UpperCamelCase__			       =     torch.from_numpy(np.arange(0					,	_lowerCAmelCase					).copy().astype(np.intaa					)					)






       def 			_lowerCamelCase						(  self					,	__lowerCAmelCase					,	__lowerCAmelCase = None					):
              return sample






       def 			_lowerCamelCase						(  self					,	__lowerCAmelCase					,	__lowerCAmelCase = None					):

              if num_inference_steps > self.config.num_train_timesteps:
                     raise ValueError(
                         f"""`num_inference_steps`: {num_inference_steps} cannot be larger than `self.config.train_timesteps`:"""
                         f""" {self.config.num_train_timesteps} as the unet model trained with this scheduler can only handle"""
                         f""" maximal {self.config.num_train_timesteps} timesteps."""					)

              UpperCamelCase__			       =     num_inference_steps
              UpperCamelCase__			       =     self.config.num_train_timesteps // self.num_inference_steps
              # creates integer timesteps by multiplying by ratio
              # casting to int to avoid issues when num_inference_step is power of 3
              UpperCamelCase__			       =     (np.arange(0					,	_lowerCAmelCase					) * step_ratio).round().copy().astype(np.intaa					)
              UpperCamelCase__			       =     torch.from_numpy(_lowerCAmelCase					).to(_lowerCAmelCase					)
              self.timesteps += self.config.steps_offset






       def 			_lowerCamelCase						(  self					,	__lowerCAmelCase					,	__lowerCAmelCase					,	__lowerCAmelCase					,	__lowerCAmelCase = 0.0					,	__lowerCAmelCase = False					,	__lowerCAmelCase = None					,	__lowerCAmelCase = True					,	):
              # 1. get previous step value (=t+1)
              UpperCamelCase__			       =     timestep + self.config.num_train_timesteps // self.num_inference_steps

              # 2. compute alphas, betas
              # change original implementation to exactly match noise levels for analogous forward process
              UpperCamelCase__			       =     self.alphas_cumprod[timestep]
              UpperCamelCase__			       =     (
                  self.alphas_cumprod[prev_timestep]
                  if prev_timestep < self.config.num_train_timesteps
                  else self.final_alpha_cumprod
              )

              UpperCamelCase__			       =     1 - alpha_prod_t

              # 3. compute predicted original sample from predicted noise also called
              # "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
              if self.config.prediction_type == "epsilon":
                     UpperCamelCase__			       =     (sample - beta_prod_t ** 0.5 * model_output) / alpha_prod_t ** 0.5
                     UpperCamelCase__			       =     model_output
              elif self.config.prediction_type == "sample":
                     UpperCamelCase__			       =     model_output
                     UpperCamelCase__			       =     (sample - alpha_prod_t ** 0.5 * pred_original_sample) / beta_prod_t ** 0.5
              elif self.config.prediction_type == "v_prediction":
                     UpperCamelCase__			       =     (alpha_prod_t**0.5) * sample - (beta_prod_t**0.5) * model_output
                     UpperCamelCase__			       =     (alpha_prod_t**0.5) * model_output + (beta_prod_t**0.5) * sample
              else:
                     raise ValueError(
                         f"""prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`, or"""
                         """ `v_prediction`"""					)

              # 4. Clip or threshold "predicted x_0"
              if self.config.clip_sample:
                     UpperCamelCase__			       =     pred_original_sample.clamp(
                         -self.config.clip_sample_range					,	self.config.clip_sample_range					)

              # 5. compute "direction pointing to x_t" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
              UpperCamelCase__			       =     (1 - alpha_prod_t_prev) ** 0.5 * pred_epsilon

              # 6. compute x_t without "random noise" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
              UpperCamelCase__			       =     alpha_prod_t_prev ** 0.5 * pred_original_sample + pred_sample_direction

              if not return_dict:
                     return (prev_sample, pred_original_sample)
              return DDIMSchedulerOutput(prev_sample=_lowerCAmelCase					,	pred_original_sample=_lowerCAmelCase					)







       def __len__(  self					):
              return self.config.num_train_timesteps











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       : Any         =    UperNetConfig
							snake_case       : List[Any]         =    """pixel_values"""
							snake_case       : Optional[Any]         =    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					,	)




