



import unittest

from transformers import XLMConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
       import torch

       from transformers import (
           XLMForMultipleChoice,
           XLMForQuestionAnswering,
           XLMForQuestionAnsweringSimple,
           XLMForSequenceClassification,
           XLMForTokenClassification,
           XLMModel,
           XLMWithLMHeadModel,
       )
       from transformers.models.xlm.modeling_xlm import XLM_PRETRAINED_MODEL_ARCHIVE_LIST



class    UpperCAmelCase__:

   '''simple docstring'''




   def __init__(    self	:      Dict      ,					lowerCAmelCase	:      Optional[Any]      ,					lowerCAmelCase	:      Tuple=13      ,					lowerCAmelCase	:      Tuple=7      ,					lowerCAmelCase	:      Any=True      ,					lowerCAmelCase	:      int=True      ,					lowerCAmelCase	:      Optional[Any]=True      ,					lowerCAmelCase	:      Optional[int]=True      ,					lowerCAmelCase	:      Dict=True      ,					lowerCAmelCase	:      Tuple=False      ,					lowerCAmelCase	:      Optional[Any]=False      ,					lowerCAmelCase	:      int=False      ,					lowerCAmelCase	:      Dict=2      ,					lowerCAmelCase	:      List[str]=99      ,					lowerCAmelCase	:      Union[str, Any]=0      ,					lowerCAmelCase	:      Union[str, Any]=32      ,					lowerCAmelCase	:      Optional[Any]=5      ,					lowerCAmelCase	:      Optional[Any]=4      ,					lowerCAmelCase	:      List[str]=0.1      ,					lowerCAmelCase	:      int=0.1      ,					lowerCAmelCase	:      List[str]=5_12      ,					lowerCAmelCase	:      Optional[int]=2      ,					lowerCAmelCase	:      Tuple=0.02      ,					lowerCAmelCase	:      Optional[Any]=2      ,					lowerCAmelCase	:      str=4      ,					lowerCAmelCase	:      Union[str, Any]="last"      ,					lowerCAmelCase	:      Any=True      ,					lowerCAmelCase	:      Any=None      ,					lowerCAmelCase	:      Tuple=0      ,					)						->					Optional[Any]:




         """simple docstring"""

         lowercase__  =	parent
         lowercase__  =	batch_size
         lowercase__  =	seq_length
         lowercase__  =	is_training
         lowercase__  =	use_input_lengths
         lowercase__  =	use_token_type_ids
         lowercase__  =	use_labels
         lowercase__  =	gelu_activation
         lowercase__  =	sinusoidal_embeddings
         lowercase__  =	causal
         lowercase__  =	asm
         lowercase__  =	n_langs
         lowercase__  =	vocab_size
         lowercase__  =	n_special
         lowercase__  =	hidden_size
         lowercase__  =	num_hidden_layers
         lowercase__  =	num_attention_heads
         lowercase__  =	hidden_dropout_prob
         lowercase__  =	attention_probs_dropout_prob
         lowercase__  =	max_position_embeddings
         lowercase__  =	type_sequence_label_size
         lowercase__  =	initializer_range
         lowercase__  =	num_labels
         lowercase__  =	num_choices
         lowercase__  =	summary_type
         lowercase__  =	use_proj
         lowercase__  =	scope
         lowercase__  =	bos_token_id


   def       UpperCAmelCase		(    self	:      List[str])						->					str:




         """simple docstring"""

         lowercase__  =	ids_tensor([self.batch_size, self.seq_length]      ,					self.vocab_size)
         lowercase__  =	random_attention_mask([self.batch_size, self.seq_length])

         lowercase__  =	None
         if self.use_input_lengths:
               lowercase__  =	(
                   ids_tensor([self.batch_size]      ,					vocab_size=2) + self.seq_length - 2
               )  # small variation of seq_length

         lowercase__  =	None
         if self.use_token_type_ids:
               lowercase__  =	ids_tensor([self.batch_size, self.seq_length]      ,					self.n_langs)

         lowercase__  =	None
         lowercase__  =	None
         lowercase__  =	None
         if self.use_labels:
               lowercase__  =	ids_tensor([self.batch_size]      ,					self.type_sequence_label_size)
               lowercase__  =	ids_tensor([self.batch_size, self.seq_length]      ,					self.num_labels)
               lowercase__  =	ids_tensor([self.batch_size]      ,					2).float()
               lowercase__  =	ids_tensor([self.batch_size]      ,					self.num_choices)

         lowercase__  =	self.get_config()

         return (
             config,
             input_ids,
             token_type_ids,
             input_lengths,
             sequence_labels,
             token_labels,
             is_impossible_labels,
             choice_labels,
             input_mask,
         )


   def       UpperCAmelCase		(    self	:      Dict)						->					Dict:




         """simple docstring"""

         return XLMConfig(
             vocab_size=self.vocab_size      ,					n_special=self.n_special      ,					emb_dim=self.hidden_size      ,					n_layers=self.num_hidden_layers      ,					n_heads=self.num_attention_heads      ,					dropout=self.hidden_dropout_prob      ,					attention_dropout=self.attention_probs_dropout_prob      ,					gelu_activation=self.gelu_activation      ,					sinusoidal_embeddings=self.sinusoidal_embeddings      ,					asm=self.asm      ,					causal=self.causal      ,					n_langs=self.n_langs      ,					max_position_embeddings=self.max_position_embeddings      ,					initializer_range=self.initializer_range      ,					summary_type=self.summary_type      ,					use_proj=self.use_proj      ,					num_labels=self.num_labels      ,					bos_token_id=self.bos_token_id      ,					)


   def       UpperCAmelCase		(    self	:      List[str]      ,					lowerCAmelCase	:      List[Any]      ,					lowerCAmelCase	:      Optional[Any]      ,					lowerCAmelCase	:      Optional[Any]      ,					lowerCAmelCase	:      List[str]      ,					lowerCAmelCase	:      Dict      ,					lowerCAmelCase	:      Optional[int]      ,					lowerCAmelCase	:      str      ,					lowerCAmelCase	:      List[Any]      ,					lowerCAmelCase	:      Any      ,					)						->					str:




         """simple docstring"""

         lowercase__  =	XLMModel(config=lowerCAmelCase)
         model.to(lowerCAmelCase)
         model.eval()
         lowercase__  =	model(lowerCAmelCase      ,					lengths=lowerCAmelCase      ,					langs=lowerCAmelCase)
         lowercase__  =	model(lowerCAmelCase      ,					langs=lowerCAmelCase)
         lowercase__  =	model(lowerCAmelCase)
         self.parent.assertEqual(result.last_hidden_state.shape      ,					(self.batch_size, self.seq_length, self.hidden_size))


   def       UpperCAmelCase		(    self	:      Optional[Any]      ,					lowerCAmelCase	:      Tuple      ,					lowerCAmelCase	:      Optional[int]      ,					lowerCAmelCase	:      Optional[Any]      ,					lowerCAmelCase	:      int      ,					lowerCAmelCase	:      Union[str, Any]      ,					lowerCAmelCase	:      Optional[int]      ,					lowerCAmelCase	:      int      ,					lowerCAmelCase	:      Union[str, Any]      ,					lowerCAmelCase	:      List[Any]      ,					)						->					str:




         """simple docstring"""

         lowercase__  =	XLMWithLMHeadModel(lowerCAmelCase)
         model.to(lowerCAmelCase)
         model.eval()

         lowercase__  =	model(lowerCAmelCase      ,					token_type_ids=lowerCAmelCase      ,					labels=lowerCAmelCase)
         self.parent.assertEqual(result.loss.shape      ,					())
         self.parent.assertEqual(result.logits.shape      ,					(self.batch_size, self.seq_length, self.vocab_size))


   def       UpperCAmelCase		(    self	:      Dict      ,					lowerCAmelCase	:      Any      ,					lowerCAmelCase	:      List[Any]      ,					lowerCAmelCase	:      List[Any]      ,					lowerCAmelCase	:      Dict      ,					lowerCAmelCase	:      Tuple      ,					lowerCAmelCase	:      Optional[Any]      ,					lowerCAmelCase	:      List[str]      ,					lowerCAmelCase	:      List[Any]      ,					lowerCAmelCase	:      str      ,					)						->					Any:




         """simple docstring"""

         lowercase__  =	XLMForQuestionAnsweringSimple(lowerCAmelCase)
         model.to(lowerCAmelCase)
         model.eval()

         lowercase__  =	model(lowerCAmelCase)

         lowercase__  =	model(lowerCAmelCase      ,					start_positions=lowerCAmelCase      ,					end_positions=lowerCAmelCase)
         lowercase__  =	outputs
         self.parent.assertEqual(result.start_logits.shape      ,					(self.batch_size, self.seq_length))
         self.parent.assertEqual(result.end_logits.shape      ,					(self.batch_size, self.seq_length))


   def       UpperCAmelCase		(    self	:      Optional[int]      ,					lowerCAmelCase	:      List[Any]      ,					lowerCAmelCase	:      Union[str, Any]      ,					lowerCAmelCase	:      Any      ,					lowerCAmelCase	:      Optional[int]      ,					lowerCAmelCase	:      Optional[Any]      ,					lowerCAmelCase	:      Optional[int]      ,					lowerCAmelCase	:      Any      ,					lowerCAmelCase	:      int      ,					lowerCAmelCase	:      Dict      ,					)						->					Optional[Any]:




         """simple docstring"""

         lowercase__  =	XLMForQuestionAnswering(lowerCAmelCase)
         model.to(lowerCAmelCase)
         model.eval()

         lowercase__  =	model(lowerCAmelCase)

         lowercase__  =	model(
             lowerCAmelCase      ,					start_positions=lowerCAmelCase      ,					end_positions=lowerCAmelCase      ,					cls_index=lowerCAmelCase      ,					is_impossible=lowerCAmelCase      ,					p_mask=lowerCAmelCase      ,					)

         lowercase__  =	model(
             lowerCAmelCase      ,					start_positions=lowerCAmelCase      ,					end_positions=lowerCAmelCase      ,					cls_index=lowerCAmelCase      ,					is_impossible=lowerCAmelCase      ,					)

         ((lowercase__						),												)  =	result_with_labels.to_tuple()

         lowercase__  =	model(lowerCAmelCase      ,					start_positions=lowerCAmelCase      ,					end_positions=lowerCAmelCase)

         ((lowercase__						),												)  =	result_with_labels.to_tuple()

         self.parent.assertEqual(result_with_labels.loss.shape      ,					())
         self.parent.assertEqual(result.start_top_log_probs.shape      ,					(self.batch_size, model.config.start_n_top))
         self.parent.assertEqual(result.start_top_index.shape      ,					(self.batch_size, model.config.start_n_top))
         self.parent.assertEqual(
             result.end_top_log_probs.shape      ,					(self.batch_size, model.config.start_n_top * model.config.end_n_top))
         self.parent.assertEqual(
             result.end_top_index.shape      ,					(self.batch_size, model.config.start_n_top * model.config.end_n_top))
         self.parent.assertEqual(result.cls_logits.shape      ,					(self.batch_size,))


   def       UpperCAmelCase		(    self	:      List[str]      ,					lowerCAmelCase	:      str      ,					lowerCAmelCase	:      Optional[int]      ,					lowerCAmelCase	:      Tuple      ,					lowerCAmelCase	:      Optional[int]      ,					lowerCAmelCase	:      Dict      ,					lowerCAmelCase	:      Dict      ,					lowerCAmelCase	:      Optional[Any]      ,					lowerCAmelCase	:      List[str]      ,					lowerCAmelCase	:      int      ,					)						->					Any:




         """simple docstring"""

         lowercase__  =	XLMForSequenceClassification(lowerCAmelCase)
         model.to(lowerCAmelCase)
         model.eval()

         lowercase__  =	model(lowerCAmelCase)
         lowercase__  =	model(lowerCAmelCase      ,					labels=lowerCAmelCase)
         self.parent.assertEqual(result.loss.shape      ,					())
         self.parent.assertEqual(result.logits.shape      ,					(self.batch_size, self.type_sequence_label_size))


   def       UpperCAmelCase		(    self	:      Tuple      ,					lowerCAmelCase	:      List[str]      ,					lowerCAmelCase	:      int      ,					lowerCAmelCase	:      Any      ,					lowerCAmelCase	:      List[Any]      ,					lowerCAmelCase	:      Optional[Any]      ,					lowerCAmelCase	:      Tuple      ,					lowerCAmelCase	:      Any      ,					lowerCAmelCase	:      Any      ,					lowerCAmelCase	:      Optional[Any]      ,					)						->					Optional[int]:




         """simple docstring"""

         lowercase__  =	self.num_labels
         lowercase__  =	XLMForTokenClassification(lowerCAmelCase)
         model.to(lowerCAmelCase)
         model.eval()

         lowercase__  =	model(lowerCAmelCase      ,					attention_mask=lowerCAmelCase      ,					labels=lowerCAmelCase)
         self.parent.assertEqual(result.logits.shape      ,					(self.batch_size, self.seq_length, self.num_labels))


   def       UpperCAmelCase		(    self	:      Dict      ,					lowerCAmelCase	:      Optional[Any]      ,					lowerCAmelCase	:      str      ,					lowerCAmelCase	:      List[str]      ,					lowerCAmelCase	:      Any      ,					lowerCAmelCase	:      str      ,					lowerCAmelCase	:      Tuple      ,					lowerCAmelCase	:      Optional[Any]      ,					lowerCAmelCase	:      Optional[int]      ,					lowerCAmelCase	:      Dict      ,					)						->					List[str]:




         """simple docstring"""

         lowercase__  =	self.num_choices
         lowercase__  =	XLMForMultipleChoice(config=lowerCAmelCase)
         model.to(lowerCAmelCase)
         model.eval()
         lowercase__  =	input_ids.unsqueeze(1).expand(-1      ,					self.num_choices      ,					-1).contiguous()
         lowercase__  =	token_type_ids.unsqueeze(1).expand(-1      ,					self.num_choices      ,					-1).contiguous()
         lowercase__  =	input_mask.unsqueeze(1).expand(-1      ,					self.num_choices      ,					-1).contiguous()
         lowercase__  =	model(
             lowerCAmelCase      ,					attention_mask=lowerCAmelCase      ,					token_type_ids=lowerCAmelCase      ,					labels=lowerCAmelCase      ,					)
         self.parent.assertEqual(result.logits.shape      ,					(self.batch_size, self.num_choices))



   def       UpperCAmelCase		(    self	:      Dict)						->					Optional[int]:




         """simple docstring"""

         lowercase__  =	self.prepare_config_and_inputs()
         (
             (
             lowercase__						
         ),						(
             lowercase__						
         ),						(
             lowercase__						
         ),						(
             lowercase__						
         ),						(
             lowercase__						
         ),						(
             lowercase__						
         ),						(
             lowercase__						
         ),						(
             lowercase__						
         ),						(
             lowercase__						
         ),												
         )  =	config_and_inputs
         lowercase__  =	{'input_ids': input_ids, 'token_type_ids': token_type_ids, 'lengths': input_lengths}
         return config, inputs_dict



@require_torch
class    UpperCAmelCase__(				__lowercase  ,				__lowercase  ,				__lowercase  ,				unittest.TestCase						):

   '''simple docstring'''




   A     :	Optional[Any]												=     (
       (
           XLMModel,
           XLMWithLMHeadModel,
           XLMForQuestionAnswering,
           XLMForSequenceClassification,
           XLMForQuestionAnsweringSimple,
           XLMForTokenClassification,
           XLMForMultipleChoice,
       )
       if is_torch_available()
       else ()
   )
   A     :	Any												=     (
       (XLMWithLMHeadModel,) if is_torch_available() else ()
   )  # TODO (PVP): Check other models whether language generation is also applicable
   A     :	List[str]												=     (
       {
           "feature-extraction": XLMModel,
           "fill-mask": XLMWithLMHeadModel,
           "question-answering": XLMForQuestionAnsweringSimple,
           "text-classification": XLMForSequenceClassification,
           "text-generation": XLMWithLMHeadModel,
           "token-classification": XLMForTokenClassification,
           "zero-shot": XLMForSequenceClassification,
       }
       if is_torch_available()
       else {}
   )


   def       UpperCAmelCase		(    self	:      List[Any]      ,					lowerCAmelCase	:      Dict      ,					lowerCAmelCase	:      Dict      ,					lowerCAmelCase	:      Any      ,					lowerCAmelCase	:      List[str]      ,					lowerCAmelCase	:      Dict)						->					Optional[Any]:




         """simple docstring"""

         if (
             pipeline_test_casse_name == "QAPipelineTests"
             and tokenizer_name is not None
             and not tokenizer_name.endswith('Fast')
         ):
               # `QAPipelineTests` fails for a few models when the slower tokenizer are used.
               # (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
               # TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
               return True

         return False


   def       UpperCAmelCase		(    self	:      Optional[Any]      ,					lowerCAmelCase	:      Optional[Any]      ,					lowerCAmelCase	:      Dict      ,					lowerCAmelCase	:      Optional[int]=False)						->					Union[str, Any]:




         """simple docstring"""

         lowercase__  =	super()._prepare_for_class(lowerCAmelCase      ,					lowerCAmelCase      ,					return_labels=lowerCAmelCase)

         if return_labels:
               if model_class.__name__ == "XLMForQuestionAnswering":
                     lowercase__  =	torch.zeros(
                         self.model_tester.batch_size      ,					dtype=torch.long      ,					device=lowerCAmelCase)
                     lowercase__  =	torch.zeros(
                         self.model_tester.batch_size      ,					dtype=torch.long      ,					device=lowerCAmelCase)

         return inputs_dict


   def       UpperCAmelCase		(    self	:      Any)						->					Tuple:




         """simple docstring"""

         lowercase__  =	XLMModelTester(self)
         lowercase__  =	ConfigTester(self      ,					config_class=lowerCAmelCase      ,					emb_dim=37)


   def       UpperCAmelCase		(    self	:      Optional[int])						->					List[str]:




         """simple docstring"""

         self.config_tester.run_common_tests()


   def       UpperCAmelCase		(    self	:      Optional[int])						->					Dict:




         """simple docstring"""

         lowercase__  =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_model(*lowerCAmelCase)


   def       UpperCAmelCase		(    self	:      List[str])						->					str:




         """simple docstring"""

         lowercase__  =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_lm_head(*lowerCAmelCase)


   def       UpperCAmelCase		(    self	:      int)						->					Optional[int]:




         """simple docstring"""

         lowercase__  =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_simple_qa(*lowerCAmelCase)


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




         """simple docstring"""

         lowercase__  =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_qa(*lowerCAmelCase)


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




         """simple docstring"""

         lowercase__  =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_sequence_classif(*lowerCAmelCase)


   def       UpperCAmelCase		(    self	:      int)						->					List[str]:




         """simple docstring"""

         lowercase__  =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_token_classif(*lowerCAmelCase)


   def       UpperCAmelCase		(    self	:      Dict)						->					List[Any]:




         """simple docstring"""

         lowercase__  =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_for_multiple_choice(*lowerCAmelCase)


   def       UpperCAmelCase		(    self	:      Tuple      ,					lowerCAmelCase	:      Tuple      ,					lowerCAmelCase	:      Tuple      ,					lowerCAmelCase	:      Dict      ,					lowerCAmelCase	:      Any      ,					lowerCAmelCase	:      List[Any]      ,					lowerCAmelCase	:      Dict=False      ,					lowerCAmelCase	:      str=1)						->					Union[str, Any]:




         """simple docstring"""

         self.assertIsInstance(lowerCAmelCase      ,					lowerCAmelCase)
         self.assertListEqual(
             [isinstance(lowerCAmelCase      ,					lowerCAmelCase) for iter_attentions in attentions]      ,					[True] * len(lowerCAmelCase))
         self.assertEqual(len(lowerCAmelCase)      ,					(max_length - min_length) * num_beam_groups)

         for idx, iter_attentions in enumerate(lowerCAmelCase):
               # adds PAD dummy token
               lowercase__  =	min_length + idx + 1
               lowercase__  =	min_length + idx + 1

               lowercase__  =	(
                   batch_size * num_beam_groups,
                   config.num_attention_heads,
                   tgt_len,
                   src_len,
               )
               # check attn size
               self.assertListEqual(
                   [layer_attention.shape for layer_attention in iter_attentions]      ,					[expected_shape] * len(lowerCAmelCase))


   def       UpperCAmelCase		(    self	:      Union[str, Any]      ,					lowerCAmelCase	:      Optional[Any]      ,					lowerCAmelCase	:      Optional[Any]      ,					lowerCAmelCase	:      List[str]      ,					lowerCAmelCase	:      Optional[int]      ,					lowerCAmelCase	:      Optional[int]      ,					lowerCAmelCase	:      Tuple=False      ,					lowerCAmelCase	:      Optional[int]=1)						->					Tuple:




         """simple docstring"""

         self.assertIsInstance(lowerCAmelCase      ,					lowerCAmelCase)
         self.assertListEqual(
             [isinstance(lowerCAmelCase      ,					lowerCAmelCase) for iter_hidden_states in hidden_states]      ,					[True] * len(lowerCAmelCase)      ,					)
         self.assertEqual(len(lowerCAmelCase)      ,					(max_length - min_length) * num_beam_groups)

         for idx, iter_hidden_states in enumerate(lowerCAmelCase):
               # adds PAD dummy token
               lowercase__  =	min_length + idx + 1
               lowercase__  =	(batch_size * num_beam_groups, seq_len, config.hidden_size)
               # check hidden size
               self.assertListEqual(
                   [layer_hidden_states.shape for layer_hidden_states in iter_hidden_states]      ,					[expected_shape] * len(lowerCAmelCase)      ,					)
         pass



   @slow
   def       UpperCAmelCase		(    self	:      int)						->					List[str]:




         """simple docstring"""

         for model_name in XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               lowercase__  =	XLMModel.from_pretrained(lowerCAmelCase)
               self.assertIsNotNone(lowerCAmelCase)



@require_torch
class    UpperCAmelCase__(				unittest.TestCase						):

   '''simple docstring'''




   @slow
   def       UpperCAmelCase		(    self	:      Optional[int])						->					List[str]:




         """simple docstring"""

         lowercase__  =	XLMWithLMHeadModel.from_pretrained('xlm-mlm-en-2048')
         model.to(lowerCAmelCase)
         lowercase__  =	torch.tensor([[14, 4_47]]      ,					dtype=torch.long      ,					device=lowerCAmelCase)  # the president
         lowercase__  =	[
             14,
             4_47,
             14,
             4_47,
             14,
             4_47,
             14,
             4_47,
             14,
             4_47,
             14,
             4_47,
             14,
             4_47,
             14,
             4_47,
             14,
             4_47,
             14,
             4_47,
         ]  # the president the president the president the president the president the president the president the president the president the president
         # TODO(PVP): this and other input_ids I tried for generation give pretty bad results. Not sure why. Model might just not be made for auto-regressive inference
         lowercase__  =	model.generate(lowerCAmelCase      ,					do_sample=lowerCAmelCase)
         self.assertListEqual(output_ids[0].cpu().numpy().tolist()      ,					lowerCAmelCase)


from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowerCamelCase__						=				{
    "configuration_upernet": ["UperNetConfig"],
}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		lowerCamelCase__						=				[
		    "UperNetForSemanticSegmentation",
		    "UperNetPreTrainedModel",
		]


if TYPE_CHECKING:
		from .configuration_upernet import UperNetConfig

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_upernet import UperNetForSemanticSegmentation, UperNetPreTrainedModel


else:
		import sys

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



