

"""simple docstring"""






import inspect
import unittest

from transformers import SegformerConfig, is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
 import torch

 from transformers import (
     MODEL_MAPPING,
     SegformerForImageClassification,
     SegformerForSemanticSegmentation,
     SegformerModel,
 )
 from transformers.models.segformer.modeling_segformer import SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
 from PIL import Image

 from transformers import SegformerImageProcessor
class        _lowercase					(     __UpperCAmelCase     ):







     def 	lowerCAmelCase__    (      self       ):
      __magic_name__     =      self.config_class(**self.inputs_dict       )
      self.parent.assertTrue(hasattr(UpperCamelCase_ ,						'''hidden_sizes'''       )       )
      self.parent.assertTrue(hasattr(UpperCamelCase_ ,						'''num_attention_heads'''       )       )
      self.parent.assertTrue(hasattr(UpperCamelCase_ ,						'''num_encoder_blocks'''       )       )


class        _lowercase					:







     def __init__(      self ,						UpperCamelCase_ ,						UpperCamelCase_=13 ,						UpperCamelCase_=64 ,						UpperCamelCase_=3 ,						UpperCamelCase_=4 ,						UpperCamelCase_=[2, 2, 2, 2] ,						UpperCamelCase_=[8, 4, 2, 1] ,						UpperCamelCase_=[16, 32, 64, 128] ,						UpperCamelCase_=[1, 4, 8, 16] ,						UpperCamelCase_=[1, 2, 4, 8] ,						UpperCamelCase_=True ,						UpperCamelCase_=True ,						UpperCamelCase_="gelu" ,						UpperCamelCase_=0.1 ,						UpperCamelCase_=0.1 ,						UpperCamelCase_=0.0_2 ,						UpperCamelCase_=3 ,						UpperCamelCase_=None ,						):
      __magic_name__     =      parent
      __magic_name__     =      batch_size
      __magic_name__     =      image_size
      __magic_name__     =      num_channels
      __magic_name__     =      num_encoder_blocks
      __magic_name__     =      sr_ratios
      __magic_name__     =      depths
      __magic_name__     =      hidden_sizes
      __magic_name__     =      downsampling_rates
      __magic_name__     =      num_attention_heads
      __magic_name__     =      is_training
      __magic_name__     =      use_labels
      __magic_name__     =      hidden_act
      __magic_name__     =      hidden_dropout_prob
      __magic_name__     =      attention_probs_dropout_prob
      __magic_name__     =      initializer_range
      __magic_name__     =      num_labels
      __magic_name__     =      scope







     def 	lowerCAmelCase__    (      self       ):
      __magic_name__     =      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

      __magic_name__     =      None
      if self.use_labels:
       __magic_name__     =      ids_tensor([self.batch_size, self.image_size, self.image_size] ,						self.num_labels       )

      __magic_name__     =      self.get_config()
      return config, pixel_values, labels







     def 	lowerCAmelCase__    (      self       ):
      return SegformerConfig(
          image_size=self.image_size ,						num_channels=self.num_channels ,						num_encoder_blocks=self.num_encoder_blocks ,						depths=self.depths ,						hidden_sizes=self.hidden_sizes ,						num_attention_heads=self.num_attention_heads ,						hidden_act=self.hidden_act ,						hidden_dropout_prob=self.hidden_dropout_prob ,						attention_probs_dropout_prob=self.attention_probs_dropout_prob ,						initializer_range=self.initializer_range ,						)







     def 	lowerCAmelCase__    (      self ,						UpperCamelCase_ ,						UpperCamelCase_ ,						UpperCamelCase_       ):
      __magic_name__     =      SegformerModel(config=UpperCamelCase_       )
      model.to(UpperCamelCase_       )
      model.eval()
      __magic_name__     =      model(UpperCamelCase_       )
      __magic_name__     =      __magic_name__     =      self.image_size // (self.downsampling_rates[-1] * 2)
      self.parent.assertEqual(
          result.last_hidden_state.shape ,						(self.batch_size, self.hidden_sizes[-1], expected_height, expected_width)       )







     def 	lowerCAmelCase__    (      self ,						UpperCamelCase_ ,						UpperCamelCase_ ,						UpperCamelCase_       ):
      __magic_name__     =      self.num_labels
      __magic_name__     =      SegformerForSemanticSegmentation(UpperCamelCase_       )
      model.to(UpperCamelCase_       )
      model.eval()
      __magic_name__     =      model(UpperCamelCase_       )
      self.parent.assertEqual(
          result.logits.shape ,						(self.batch_size, self.num_labels, self.image_size // 4, self.image_size // 4)       )
      __magic_name__     =      model(UpperCamelCase_ ,						labels=UpperCamelCase_       )
      self.parent.assertEqual(
          result.logits.shape ,						(self.batch_size, self.num_labels, self.image_size // 4, self.image_size // 4)       )
      self.parent.assertGreater(result.loss ,						0.0       )







     def 	lowerCAmelCase__    (      self ,						UpperCamelCase_ ,						UpperCamelCase_ ,						UpperCamelCase_       ):
      __magic_name__     =      1
      __magic_name__     =      SegformerForSemanticSegmentation(config=UpperCamelCase_       )
      model.to(UpperCamelCase_       )
      model.eval()
      __magic_name__     =      torch.randint(0 ,						1 ,						(self.batch_size, self.image_size, self.image_size)       ).to(UpperCamelCase_       )
      __magic_name__     =      model(UpperCamelCase_ ,						labels=UpperCamelCase_       )
      self.parent.assertGreater(result.loss ,						0.0       )







     def 	lowerCAmelCase__    (      self       ):
      __magic_name__     =      self.prepare_config_and_inputs()
      __magic_name__   ,						__magic_name__   ,						__magic_name__     =      config_and_inputs
      __magic_name__     =      {'''pixel_values''': pixel_values}
      return config, inputs_dict


@require_torch
class        _lowercase					(     __UpperCAmelCase   , __UpperCAmelCase   , unittest.TestCase     ):
     _lowerCamelCase     =       (
         (
             SegformerModel,
             SegformerForSemanticSegmentation,
             SegformerForImageClassification,
         )
         if is_torch_available()
         else ()
     )
     _lowerCamelCase     =       (
         {
             '''feature-extraction''': SegformerModel,
             '''image-classification''': SegformerForImageClassification,
             '''image-segmentation''': SegformerForSemanticSegmentation,
         }
         if is_torch_available()
         else {}
     )

     _lowerCamelCase     =       True
     _lowerCamelCase     =       False
     _lowerCamelCase     =       False
     _lowerCamelCase     =       False







     def 	lowerCAmelCase__    (      self       ):
      __magic_name__     =      SegformerModelTester(self       )
      __magic_name__     =      SegformerConfigTester(self ,						config_class=UpperCamelCase_       )







     def 	lowerCAmelCase__    (      self       ):
      self.config_tester.run_common_tests()







     def 	lowerCAmelCase__    (      self       ):
      __magic_name__     =      self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*UpperCamelCase_       )







     def 	lowerCAmelCase__    (      self       ):
      __magic_name__     =      self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_binary_image_segmentation(*UpperCamelCase_       )







     def 	lowerCAmelCase__    (      self       ):
      __magic_name__     =      self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_segmentation(*UpperCamelCase_       )







     @unittest.skip('''SegFormer does not use inputs_embeds'''       )
     def 	lowerCAmelCase__    (      self       ):
      pass







     @unittest.skip('''SegFormer does not have get_input_embeddings method and get_output_embeddings methods'''       )
     def 	lowerCAmelCase__    (      self       ):
      pass







     def 	lowerCAmelCase__    (      self       ):
      __magic_name__   ,						__magic_name__     =      self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
       __magic_name__     =      model_class(UpperCamelCase_       )
       __magic_name__     =      inspect.signature(model.forward       )
       # signature.parameters is an OrderedDict => so arg_names order is deterministic
       __magic_name__     =      [*signature.parameters.keys()]

       __magic_name__     =      ['''pixel_values''']
       self.assertListEqual(arg_names[:1] ,						UpperCamelCase_       )







     def 	lowerCAmelCase__    (      self       ):
      __magic_name__   ,						__magic_name__     =      self.model_tester.prepare_config_and_inputs_for_common()
      __magic_name__     =      True

      for model_class in self.all_model_classes:
       __magic_name__     =      True
       __magic_name__     =      False
       __magic_name__     =      True
       __magic_name__     =      model_class(UpperCamelCase_       )
       model.to(UpperCamelCase_       )
       model.eval()
       with torch.no_grad():
        __magic_name__     =      model(**self._prepare_for_class(UpperCamelCase_ ,						UpperCamelCase_       )       )
       __magic_name__     =      outputs.attentions

       __magic_name__     =      sum(self.model_tester.depths       )
       self.assertEqual(len(UpperCamelCase_       ) ,						UpperCamelCase_       )

       # check that output_attentions also work using config
       del inputs_dict["output_attentions"]
       __magic_name__     =      True
       __magic_name__     =      model_class(UpperCamelCase_       )
       model.to(UpperCamelCase_       )
       model.eval()
       with torch.no_grad():
        __magic_name__     =      model(**self._prepare_for_class(UpperCamelCase_ ,						UpperCamelCase_       )       )
       __magic_name__     =      outputs.attentions

       self.assertEqual(len(UpperCamelCase_       ) ,						UpperCamelCase_       )

       # verify the first attentions (first block, first layer)
       __magic_name__     =      (self.model_tester.image_size // 4) ** 2
       __magic_name__     =      (self.model_tester.image_size // (4 * self.model_tester.sr_ratios[0])) ** 2
       self.assertListEqual(
           list(attentions[0].shape[-3:]       ) ,						[self.model_tester.num_attention_heads[0], expected_seq_len, expected_reduced_seq_len] ,						)

       # verify the last attentions (last block, last layer)
       __magic_name__     =      (self.model_tester.image_size // 32) ** 2
       __magic_name__     =      (self.model_tester.image_size // (32 * self.model_tester.sr_ratios[-1])) ** 2
       self.assertListEqual(
           list(attentions[-1].shape[-3:]       ) ,						[self.model_tester.num_attention_heads[-1], expected_seq_len, expected_reduced_seq_len] ,						)
       __magic_name__     =      len(UpperCamelCase_       )

       # Check attention is always last and order is fine
       __magic_name__     =      True
       __magic_name__     =      True
       __magic_name__     =      model_class(UpperCamelCase_       )
       model.to(UpperCamelCase_       )
       model.eval()
       with torch.no_grad():
        __magic_name__     =      model(**self._prepare_for_class(UpperCamelCase_ ,						UpperCamelCase_       )       )

       self.assertEqual(out_len + 1 ,						len(UpperCamelCase_       )       )

       __magic_name__     =      outputs.attentions

       self.assertEqual(len(UpperCamelCase_       ) ,						UpperCamelCase_       )
       # verify the first attentions (first block, first layer)
       __magic_name__     =      (self.model_tester.image_size // 4) ** 2
       __magic_name__     =      (self.model_tester.image_size // (4 * self.model_tester.sr_ratios[0])) ** 2
       self.assertListEqual(
           list(self_attentions[0].shape[-3:]       ) ,						[self.model_tester.num_attention_heads[0], expected_seq_len, expected_reduced_seq_len] ,						)







     def 	lowerCAmelCase__    (      self       ):
      def check_hidden_states_output(UpperCamelCase_ ,						UpperCamelCase_ ,						UpperCamelCase_       ):
       __magic_name__     =      model_class(UpperCamelCase_       )
       model.to(UpperCamelCase_       )
       model.eval()

       with torch.no_grad():
        __magic_name__     =      model(**self._prepare_for_class(UpperCamelCase_ ,						UpperCamelCase_       )       )

       __magic_name__     =      outputs.hidden_states

       __magic_name__     =      self.model_tester.num_encoder_blocks
       self.assertEqual(len(UpperCamelCase_       ) ,						UpperCamelCase_       )

       # verify the first hidden states (first block)
       self.assertListEqual(
           list(hidden_states[0].shape[-3:]       ) ,						[
               self.model_tester.hidden_sizes[0],
               self.model_tester.image_size // 4,
               self.model_tester.image_size // 4,
           ] ,						)

      __magic_name__   ,						__magic_name__     =      self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
       __magic_name__     =      True
       check_hidden_states_output(UpperCamelCase_ ,						UpperCamelCase_ ,						UpperCamelCase_       )

       # check that output_hidden_states also work using config
       del inputs_dict["output_hidden_states"]
       __magic_name__     =      True

       check_hidden_states_output(UpperCamelCase_ ,						UpperCamelCase_ ,						UpperCamelCase_       )







     def 	lowerCAmelCase__    (      self       ):
      if not self.model_tester.is_training:
       return

      __magic_name__   ,						__magic_name__     =      self.model_tester.prepare_config_and_inputs_for_common()
      __magic_name__     =      True

      for model_class in self.all_model_classes:
       if model_class in get_values(UpperCamelCase_       ):
        continue

       __magic_name__     =      model_class(UpperCamelCase_       )
       model.to(UpperCamelCase_       )
       model.train()
       __magic_name__     =      self._prepare_for_class(UpperCamelCase_ ,						UpperCamelCase_ ,						return_labels=UpperCamelCase_       )
       __magic_name__     =      model(**UpperCamelCase_       ).loss
       loss.backward()







     @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''       )
     def 	lowerCAmelCase__    (      self       ):
      pass







     @slow
     def 	lowerCAmelCase__    (      self       ):
      for model_name in SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       __magic_name__     =      SegformerModel.from_pretrained(UpperCamelCase_       )
       self.assertIsNotNone(UpperCamelCase_       )





def 	lowercase      (   ) ->      Dict:
 __magic_name__     =      Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''						)
 return image
@require_torch
class        _lowercase					(     unittest.TestCase     ):







     @slow
     def 	lowerCAmelCase__    (      self       ):
      # only resize + normalize
      __magic_name__     =      SegformerImageProcessor(
          image_scale=(512, 512) ,						keep_ratio=UpperCamelCase_ ,						align=UpperCamelCase_ ,						do_random_crop=UpperCamelCase_       )
      __magic_name__     =      SegformerForSemanticSegmentation.from_pretrained('''nvidia/segformer-b0-finetuned-ade-512-512'''       ).to(
          UpperCamelCase_       )

      __magic_name__     =      prepare_img()
      __magic_name__     =      image_processor(images=UpperCamelCase_ ,						return_tensors='''pt'''       )
      __magic_name__     =      encoded_inputs.pixel_values.to(UpperCamelCase_       )

      with torch.no_grad():
       __magic_name__     =      model(UpperCamelCase_       )

      __magic_name__     =      torch.Size((1, model.config.num_labels, 128, 128)       )
      self.assertEqual(outputs.logits.shape ,						UpperCamelCase_       )

      __magic_name__     =      torch.tensor(
          [
              [[-4.6_3_1_0, -5.5_2_3_2, -6.2_3_5_6], [-5.1_9_2_1, -6.1_4_4_4, -6.5_9_9_6], [-5.4_4_2_4, -6.2_7_9_0, -6.7_5_7_4]],
              [[-1_2.1_3_9_1, -1_3.3_1_2_2, -1_3.9_5_5_4], [-1_2.8_7_3_2, -1_3.9_3_5_2, -1_4.3_5_6_3], [-1_2.9_4_3_8, -1_3.8_2_2_6, -1_4.2_5_1_3]],
              [[-1_2.5_1_3_4, -1_3.4_6_8_6, -1_4.4_9_1_5], [-1_2.8_6_6_9, -1_4.4_3_4_3, -1_4.7_7_5_8], [-1_3.2_5_2_3, -1_4.5_8_1_9, -1_5.0_6_9_4]],
          ]       ).to(UpperCamelCase_       )
      self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3] ,						UpperCamelCase_ ,						atol=1E-4       )       )







     @slow
     def 	lowerCAmelCase__    (      self       ):
      # only resize + normalize
      __magic_name__     =      SegformerImageProcessor(
          image_scale=(512, 512) ,						keep_ratio=UpperCamelCase_ ,						align=UpperCamelCase_ ,						do_random_crop=UpperCamelCase_       )
      __magic_name__     =      SegformerForSemanticSegmentation.from_pretrained(
          '''nvidia/segformer-b1-finetuned-cityscapes-1024-1024'''       ).to(UpperCamelCase_       )

      __magic_name__     =      prepare_img()
      __magic_name__     =      image_processor(images=UpperCamelCase_ ,						return_tensors='''pt'''       )
      __magic_name__     =      encoded_inputs.pixel_values.to(UpperCamelCase_       )

      with torch.no_grad():
       __magic_name__     =      model(UpperCamelCase_       )

      __magic_name__     =      torch.Size((1, model.config.num_labels, 128, 128)       )
      self.assertEqual(outputs.logits.shape ,						UpperCamelCase_       )

      __magic_name__     =      torch.tensor(
          [
              [[-1_3.5_7_4_8, -1_3.9_1_1_1, -1_2.6_5_0_0], [-1_4.3_5_0_0, -1_5.3_6_8_3, -1_4.2_3_2_8], [-1_4.7_5_3_2, -1_6.0_4_2_4, -1_5.6_0_8_7]],
              [[-1_7.1_6_5_1, -1_5.8_7_2_5, -1_2.9_6_5_3], [-1_7.2_5_8_0, -1_7.3_7_1_8, -1_4.8_2_2_3], [-1_6.6_0_5_8, -1_6.8_7_8_3, -1_6.7_4_5_2]],
              [[-3.6_4_5_6, -3.0_2_0_9, -1.4_2_0_3], [-3.0_7_9_7, -3.1_9_5_9, -2.0_0_0_0], [-1.8_7_5_7, -1.9_2_1_7, -1.6_9_9_7]],
          ]       ).to(UpperCamelCase_       )
      self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3] ,						UpperCamelCase_ ,						atol=1E-1       )       )







     @slow
     def 	lowerCAmelCase__    (      self       ):
      # only resize + normalize
      __magic_name__     =      SegformerImageProcessor(
          image_scale=(512, 512) ,						keep_ratio=UpperCamelCase_ ,						align=UpperCamelCase_ ,						do_random_crop=UpperCamelCase_       )
      __magic_name__     =      SegformerForSemanticSegmentation.from_pretrained('''nvidia/segformer-b0-finetuned-ade-512-512'''       ).to(
          UpperCamelCase_       )

      __magic_name__     =      prepare_img()
      __magic_name__     =      image_processor(images=UpperCamelCase_ ,						return_tensors='''pt'''       )
      __magic_name__     =      encoded_inputs.pixel_values.to(UpperCamelCase_       )

      with torch.no_grad():
       __magic_name__     =      model(UpperCamelCase_       )

      __magic_name__     =      outputs.logits.detach().cpu()

      __magic_name__     =      image_processor.post_process_semantic_segmentation(outputs=UpperCamelCase_ ,						target_sizes=[(500, 300)]       )
      __magic_name__     =      torch.Size((500, 300)       )
      self.assertEqual(segmentation[0].shape ,						UpperCamelCase_       )

      __magic_name__     =      image_processor.post_process_semantic_segmentation(outputs=UpperCamelCase_       )
      __magic_name__     =      torch.Size((128, 128)       )
      self.assertEqual(segmentation[0].shape ,						UpperCamelCase_       )




"""simple docstring"""






from typing import TYPE_CHECKING

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


__lowerCamelCase										=		{
    "configuration_m2m_100": ["M2M_100_PRETRAINED_CONFIG_ARCHIVE_MAP", "M2M100Config", "M2M100OnnxConfig"],
    "tokenization_m2m_100": ["M2M100Tokenizer"],
}


try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __lowerCamelCase										=		[
     "M2M_100_PRETRAINED_MODEL_ARCHIVE_LIST",
     "M2M100ForConditionalGeneration",
     "M2M100Model",
     "M2M100PreTrainedModel",
 ]


if TYPE_CHECKING:
 from .configuration_mam_aaa import M2M_100_PRETRAINED_CONFIG_ARCHIVE_MAP, MaMaaaConfig, MaMaaaOnnxConfig
 from .tokenization_mam_aaa import MaMaaaTokenizer

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_mam_aaa import (
      M2M_100_PRETRAINED_MODEL_ARCHIVE_LIST,
      MaMaaaForConditionalGeneration,
      MaMaaaModel,
      MaMaaaPreTrainedModel,
  )


else:
 import sys

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

