
'''simple docstring'''





import argparse
import logging
import os
import sys
from collections import namedtuple

import torch
from modeling_bertabs import BertAbs, build_predictor
from torch.utils.data import DataLoader, SequentialSampler
from tqdm import tqdm

from transformers import BertTokenizer

from .utils_summarization import (
    CNNDMDataset,
    build_mask,
    compute_token_type_ids,
    encode_for_summarization,
    truncate_or_pad,
)


A							     = logging.getLogger(__name__)
logging.basicConfig(stream=sys.stdout, level=logging.INFO)


A							     = namedtuple("Batch", ["document_names", "batch_size", "src", "segs", "mask_src", "tgt_str"])
def 	snake_case_							(				_a  :				str      ):
      snake_case_    							=				BertTokenizer.from_pretrained("bert-base-uncased"			,       do_lower_case=_a      )
      snake_case_    							=				BertAbs.from_pretrained("remi/bertabs-finetuned-extractive-abstractive-summarization"      )
      model.to(args.device      )
      model.eval()

      snake_case_    							=				{
          "BOS": tokenizer.vocab["[unused0]"],
          "EOS": tokenizer.vocab["[unused1]"],
          "PAD": tokenizer.vocab["[PAD]"],
      }

      if args.compute_rouge:
            snake_case_    							=				[]
            snake_case_    							=				[]

            import nltk
            import rouge

            nltk.download("punkt"      )
            snake_case_    							=				rouge.Rouge(
                metrics=["rouge-n", "rouge-l"]			,       max_n=2			,       limit_length=_a			,       length_limit=args.beam_size			,       length_limit_type="words"			,       apply_avg=_a			,       apply_best=_a			,       alpha=0.5			,       weight_factor=1.2			,       stemming=_a			,       )

      # these (unused) arguments are defined to keep the compatibility
      # with the legacy code and will be deleted in a next iteration.
      snake_case_    							=				""
      snake_case_    							=				""

      snake_case_    							=				build_data_iterator(_a			,       _a      )
      snake_case_    							=				build_predictor(_a			,       _a			,       _a			,       _a      )

      logger.info("***** Running evaluation *****"      )
      logger.info("  Number examples = %d"			,       len(data_iterator.dataset      )      )
      logger.info("  Batch size = %d"			,       args.batch_size      )
      logger.info(""      )
      logger.info("***** Beam Search parameters *****"      )
      logger.info("  Beam size = %d"			,       args.beam_size      )
      logger.info("  Minimum length = %d"			,       args.min_length      )
      logger.info("  Maximum length = %d"			,       args.max_length      )
      logger.info("  Alpha (length penalty) = %.2f"			,       args.alpha      )
      logger.info("  Trigrams %s be blocked"			,       ("will" if args.block_trigram else "will NOT")      )

      for batch in tqdm(_a      ):
            snake_case_    							=				predictor.translate_batch(_a      )
            snake_case_    							=				predictor.from_batch(_a      )
            snake_case_    							=				[format_summary(_a      ) for t in translations]
            save_summaries(_a			,       args.summaries_output_dir			,       batch.document_names      )

            if args.compute_rouge:
                  reference_summaries += batch.tgt_str
                  generated_summaries += summaries

      if args.compute_rouge:
            snake_case_    							=				rouge_evaluator.get_scores(_a			,       _a      )
            snake_case_    							=				format_rouge_scores(_a      )
            save_rouge_scores(_a      )
            print(_a      )
def 	snake_case_							(				_a  :				List[Any]			,       _a  :				List[str]			,       _a  :				Any      ):
      for summary, document_name in zip(_a			,       _a      ):
            # Prepare the summary file's name
            if "." in document_name:
                  snake_case_    							=				".".join(document_name.split("."      )[:-1]      )
                  snake_case_    							=				document_name.split("."      )[-1]
                  snake_case_    							=				bare_document_name + "_summary." + extension
            else:
                  snake_case_    							=				document_name + "_summary"

            snake_case_    							=				os.path.join(_a			,       _a      )
            with open(_a			,       "w"      ) as output:
                  output.write(_a      )
def 	snake_case_							(				_a  :				Optional[int]      ):
      snake_case_							,						snake_case_							,						snake_case_    							=				translation
      snake_case_    							=				(
          raw_summary.replace("[unused0]"			,       ""      )
          .replace("[unused3]"			,       ""      )
          .replace("[PAD]"			,       ""      )
          .replace("[unused1]"			,       ""      )
          .replace(R" +"			,       " "      )
          .replace(" [unused2] "			,       ". "      )
          .replace("[unused2]"			,       ""      )
          .strip()
      )

      return summary
def 	snake_case_							(				_a  :				str      ):
      return """\n
****** ROUGE SCORES ******

** ROUGE 1
F1        >> {:.3f}
Precision >> {:.3f}
Recall    >> {:.3f}

** ROUGE 2
F1        >> {:.3f}
Precision >> {:.3f}
Recall    >> {:.3f}

** ROUGE L
F1        >> {:.3f}
Precision >> {:.3f}
Recall    >> {:.3f}""".format(
          scores["rouge-1"]["f"]			,       scores["rouge-1"]["p"]			,       scores["rouge-1"]["r"]			,       scores["rouge-2"]["f"]			,       scores["rouge-2"]["p"]			,       scores["rouge-2"]["r"]			,       scores["rouge-l"]["f"]			,       scores["rouge-l"]["p"]			,       scores["rouge-l"]["r"]			,       )
def 	snake_case_							(				_a  :				str      ):
      with open("rouge_scores.txt"			,       "w"      ) as output:
            output.write(_a      )
def 	snake_case_							(				_a  :				Tuple			,       _a  :				Union[str, Any]      ):
      snake_case_    							=				load_and_cache_examples(_a			,       _a      )
      snake_case_    							=				SequentialSampler(_a      )

      def collate_fn(_a  :				Tuple      ):
            return collate(_a			,       _a			,       block_size=512			,       device=args.device      )

      snake_case_    							=				DataLoader(
          _a			,       sampler=_a			,       batch_size=args.batch_size			,       collate_fn=_a			,       )

      return iterator
def 	snake_case_							(				_a  :				Optional[Any]			,       _a  :				Tuple      ):
      snake_case_    							=				CNNDMDataset(args.documents_dir      )
      return dataset
def 	snake_case_							(				_a  :				int			,       _a  :				int			,       _a  :				str			,       _a  :				List[Any]      ):
      snake_case_    							=				[x for x in data if not len(x[1]      ) == 0]  # remove empty_files
      snake_case_    							=				[name for name, _, _ in data]
      snake_case_    							=				[" ".join(_a      ) for _, _, summary_list in data]

      snake_case_    							=				[encode_for_summarization(_a			,       _a			,       _a      ) for _, story, summary in data]
      snake_case_    							=				torch.tensor(
          [truncate_or_pad(_a			,       _a			,       tokenizer.pad_token_id      ) for story, _ in encoded_text]      )
      snake_case_    							=				compute_token_type_ids(_a			,       tokenizer.cls_token_id      )
      snake_case_    							=				build_mask(_a			,       tokenizer.pad_token_id      )

      snake_case_    							=				Batch(
          document_names=_a			,       batch_size=len(_a      )			,       src=encoded_stories.to(_a      )			,       segs=encoder_token_type_ids.to(_a      )			,       mask_src=encoder_mask.to(_a      )			,       tgt_str=_a			,       )

      return batch
def 	snake_case_							(				_a  :				Tuple			,       _a  :				int      ):
      snake_case_    							=				summary_tokens.to("cpu"      ).numpy()
      snake_case_    							=				tokenizer.decode(_a      )
      snake_case_    							=				summary.split("."      )
      snake_case_    							=				[s + "." for s in sentences]
      return sentences
def 	snake_case_							(				):
      snake_case_    							=				argparse.ArgumentParser()
      parser.add_argument(
          "--documents_dir"			,       default=_a			,       type=_a			,       required=_a			,       help="The folder where the documents to summarize are located."			,       )
      parser.add_argument(
          "--summaries_output_dir"			,       default=_a			,       type=_a			,       required=_a			,       help="The folder in wich the summaries should be written. Defaults to the folder where the documents are"			,       )
      parser.add_argument(
          "--compute_rouge"			,       default=_a			,       type=_a			,       required=_a			,       help="Compute the ROUGE metrics during evaluation. Only available for the CNN/DailyMail dataset."			,       )
      # EVALUATION options
      parser.add_argument(
          "--no_cuda"			,       default=_a			,       type=_a			,       help="Whether to force the execution on CPU."			,       )
      parser.add_argument(
          "--batch_size"			,       default=4			,       type=_a			,       help="Batch size per GPU/CPU for training."			,       )
      # BEAM SEARCH arguments
      parser.add_argument(
          "--min_length"			,       default=50			,       type=_a			,       help="Minimum number of tokens for the summaries."			,       )
      parser.add_argument(
          "--max_length"			,       default=200			,       type=_a			,       help="Maixmum number of tokens for the summaries."			,       )
      parser.add_argument(
          "--beam_size"			,       default=5			,       type=_a			,       help="The number of beams to start with for each example."			,       )
      parser.add_argument(
          "--alpha"			,       default=0.9_5			,       type=_a			,       help="The value of alpha for the length penalty in the beam search."			,       )
      parser.add_argument(
          "--block_trigram"			,       default=_a			,       type=_a			,       help="Whether to block the existence of repeating trigrams in the text generated by beam search."			,       )
      snake_case_    							=				parser.parse_args()

      # Select device (distibuted not available)
      snake_case_    							=				torch.device("cuda" if torch.cuda.is_available() and not args.no_cuda else "cpu"      )

      # Check the existence of directories
      if not args.summaries_output_dir:
            snake_case_    							=				args.documents_dir

      if not documents_dir_is_valid(args.documents_dir      ):
            raise FileNotFoundError(
                "We could not find the directory you specified for the documents to summarize, or it was empty. Please"
                " specify a valid path."      )
      os.makedirs(args.summaries_output_dir			,       exist_ok=_a      )

      evaluate(_a      )
def 	snake_case_							(				_a  :				Optional[int]      ):
      if not os.path.exists(_a      ):
            return False

      snake_case_    							=				os.listdir(_a      )
      if len(_a      ) == 0:
            return False

      return True


if __name__ == "__main__":
     main()


"""simple docstring"""
import inspect
import unittest

from transformers import DPTConfig
from transformers.file_utils import is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

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


if is_torch_available():
					import torch
					from torch import nn

					from transformers import MODEL_MAPPING, DPTForDepthEstimation, DPTForSemanticSegmentation, DPTModel
					from transformers.models.dpt.modeling_dpt import DPT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
					from PIL import Image

					from transformers import DPTImageProcessor



class 	lowerCAmelCase_     :



				"""simple docstring"""

				def __init__(					self		,     lowerCAmelCase		,     lowerCAmelCase=2		,     lowerCAmelCase=32		,     lowerCAmelCase=16		,     lowerCAmelCase=3		,     lowerCAmelCase=True		,     lowerCAmelCase=True		,     lowerCAmelCase=32		,     lowerCAmelCase=4		,     lowerCAmelCase=[0, 1, 2, 3]		,     lowerCAmelCase=4		,     lowerCAmelCase=37		,     lowerCAmelCase="gelu"		,     lowerCAmelCase=0.1		,     lowerCAmelCase=0.1		,     lowerCAmelCase=0.02		,     lowerCAmelCase=3		,     lowerCAmelCase=False		,     lowerCAmelCase=None		,     ):






										"""simple docstring"""

										snake_case             =      parent
										snake_case             =      batch_size
										snake_case             =      image_size
										snake_case             =      patch_size
										snake_case             =      num_channels
										snake_case             =      is_training
										snake_case             =      use_labels
										snake_case             =      hidden_size
										snake_case             =      num_hidden_layers
										snake_case             =      backbone_out_indices
										snake_case             =      num_attention_heads
										snake_case             =      intermediate_size
										snake_case             =      hidden_act
										snake_case             =      hidden_dropout_prob
										snake_case             =      attention_probs_dropout_prob
										snake_case             =      initializer_range
										snake_case             =      num_labels
										snake_case             =      scope
										snake_case             =      is_hybrid
										# sequence length of DPT = num_patches + 1 (we add 1 for the [CLS] token)
										snake_case             =      (image_size // patch_size) ** 2
										snake_case             =      num_patches + 1

				def 		snake_case			(					self     ):






										"""simple docstring"""

										snake_case             =      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

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

										snake_case             =      self.get_config()

										return config, pixel_values, labels

				def 		snake_case			(					self     ):






										"""simple docstring"""

										return DPTConfig(
										    image_size=self.image_size		,     patch_size=self.patch_size		,     num_channels=self.num_channels		,     hidden_size=self.hidden_size		,     num_hidden_layers=self.num_hidden_layers		,     backbone_out_indices=self.backbone_out_indices		,     num_attention_heads=self.num_attention_heads		,     intermediate_size=self.intermediate_size		,     hidden_act=self.hidden_act		,     hidden_dropout_prob=self.hidden_dropout_prob		,     attention_probs_dropout_prob=self.attention_probs_dropout_prob		,     is_decoder=lowerCAmelCase		,     initializer_range=self.initializer_range		,     is_hybrid=self.is_hybrid		,     )

				def 		snake_case			(					self		,     lowerCAmelCase		,     lowerCAmelCase		,     lowerCAmelCase     ):






										"""simple docstring"""

										snake_case             =      DPTModel(config=lowerCAmelCase     )
										model.to(lowerCAmelCase     )
										model.eval()
										snake_case             =      model(lowerCAmelCase     )
										self.parent.assertEqual(result.last_hidden_state.shape		,     (self.batch_size, self.seq_length, self.hidden_size)     )

				def 		snake_case			(					self		,     lowerCAmelCase		,     lowerCAmelCase		,     lowerCAmelCase     ):






										"""simple docstring"""

										snake_case             =      self.num_labels
										snake_case             =      DPTForDepthEstimation(lowerCAmelCase     )
										model.to(lowerCAmelCase     )
										model.eval()
										snake_case             =      model(lowerCAmelCase     )
										self.parent.assertEqual(result.predicted_depth.shape		,     (self.batch_size, self.image_size, self.image_size)     )

				def 		snake_case			(					self		,     lowerCAmelCase		,     lowerCAmelCase		,     lowerCAmelCase     ):






										"""simple docstring"""

										snake_case             =      self.num_labels
										snake_case             =      DPTForSemanticSegmentation(lowerCAmelCase     )
										model.to(lowerCAmelCase     )
										model.eval()
										snake_case             =      model(lowerCAmelCase		,     labels=lowerCAmelCase     )
										self.parent.assertEqual(
										    result.logits.shape		,     (self.batch_size, self.num_labels, self.image_size, self.image_size)     )

				def 		snake_case			(					self     ):






										"""simple docstring"""

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





@require_torch
class 	lowerCAmelCase_     (      lowerCAmelCase  ,     lowerCAmelCase  ,     unittest.TestCase       ):



				"""simple docstring"""
				_lowerCAmelCase  :     int      	=    (DPTModel, DPTForDepthEstimation, DPTForSemanticSegmentation) if is_torch_available() else ()
				_lowerCAmelCase  :     List[str]      	=    (
				    {
				        """depth-estimation""": DPTForDepthEstimation,
				        """feature-extraction""": DPTModel,
				        """image-segmentation""": DPTForSemanticSegmentation,
				    }
				    if is_torch_available()
				    else {}
				)

				_lowerCAmelCase  :     str      	=    False
				_lowerCAmelCase  :     Any      	=    False
				_lowerCAmelCase  :     Dict      	=    False

				def 		snake_case			(					self     ):






										"""simple docstring"""

										snake_case             =      DPTModelTester(self     )
										snake_case             =      ConfigTester(self		,     config_class=lowerCAmelCase		,     has_text_modality=lowerCAmelCase		,     hidden_size=37     )

				def 		snake_case			(					self     ):






										"""simple docstring"""

										self.config_tester.run_common_tests()

				@unittest.skip(reason='DPT does not use inputs_embeds'     )
				def 		snake_case			(					self     ):






										"""simple docstring"""

										pass

				def 		snake_case			(					self     ):






										"""simple docstring"""

										snake_case       ,snake_case             =      self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
																snake_case             =      model_class(lowerCAmelCase     )
																self.assertIsInstance(model.get_input_embeddings()		,     (nn.Module)     )
																snake_case             =      model.get_output_embeddings()
																self.assertTrue(x is None or isinstance(lowerCAmelCase		,     nn.Linear     )     )

				def 		snake_case			(					self     ):






										"""simple docstring"""

										snake_case       ,snake_case             =      self.model_tester.prepare_config_and_inputs_for_common()

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

																snake_case             =      ['pixel_values']
																self.assertListEqual(arg_names[:1]		,     lowerCAmelCase     )

				def 		snake_case			(					self     ):






										"""simple docstring"""

										snake_case             =      self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*lowerCAmelCase     )

				def 		snake_case			(					self     ):






										"""simple docstring"""

										snake_case             =      self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_depth_estimation(*lowerCAmelCase     )

				def 		snake_case			(					self     ):






										"""simple docstring"""

										snake_case             =      self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_semantic_segmentation(*lowerCAmelCase     )

				def 		snake_case			(					self     ):






										"""simple docstring"""

										for model_class in self.all_model_classes:
																if model_class.__name__ == "DPTForDepthEstimation":
																						continue

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

																if model_class in get_values(lowerCAmelCase     ):
																						continue

																snake_case             =      model_class(lowerCAmelCase     )
																model.to(lowerCAmelCase     )
																model.train()
																snake_case             =      self._prepare_for_class(lowerCAmelCase		,     lowerCAmelCase		,     return_labels=lowerCAmelCase     )
																snake_case             =      model(**lowerCAmelCase     ).loss
																loss.backward()

				def 		snake_case			(					self     ):






										"""simple docstring"""

										for model_class in self.all_model_classes:
																if model_class.__name__ == "DPTForDepthEstimation":
																						continue

																snake_case       ,snake_case             =      self.model_tester.prepare_config_and_inputs_for_common()
																snake_case             =      False
																snake_case             =      True

																if model_class in get_values(lowerCAmelCase     ) or not model_class.supports_gradient_checkpointing:
																						continue
																snake_case             =      model_class(lowerCAmelCase     )
																model.to(lowerCAmelCase     )
																model.gradient_checkpointing_enable()
																model.train()
																snake_case             =      self._prepare_for_class(lowerCAmelCase		,     lowerCAmelCase		,     return_labels=lowerCAmelCase     )
																snake_case             =      model(**lowerCAmelCase     ).loss
																loss.backward()

				def 		snake_case			(					self     ):






										"""simple docstring"""

										snake_case       ,snake_case             =      self.model_tester.prepare_config_and_inputs_for_common()

										snake_case             =      _config_zero_init(lowerCAmelCase     )
										for model_class in self.all_model_classes:
																snake_case             =      model_class(config=lowerCAmelCase     )
																# Skip the check for the backbone
																snake_case             =      []
																for name, module in model.named_modules():
																						if module.__class__.__name__ == "DPTViTHybridEmbeddings":
																												snake_case             =      [F"""{name}.{key}""" for key in module.state_dict().keys()]
																												break

																for name, param in model.named_parameters():
																						if param.requires_grad:
																												if name in backbone_params:
																																		continue
																												self.assertIn(
																												    ((param.data.mean() * 1E9).round() / 1E9).item()		,     [0.0, 1.0]		,     msg=F"""Parameter {name} of model {model_class} seems not properly initialized"""		,     )

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






										"""simple docstring"""

										pass

				@slow
				def 		snake_case			(					self     ):






										"""simple docstring"""

										for model_name in DPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																snake_case             =      DPTModel.from_pretrained(lowerCAmelCase     )
																self.assertIsNotNone(lowerCAmelCase     )





def  lowerCAmelCase__     (      )       ->					Union[str, Any]:





						"""simple docstring"""






						snake_case             =      Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'       )
						return image



@require_torch
@require_vision
@slow
class 	lowerCAmelCase_     (      unittest.TestCase       ):



				"""simple docstring"""

				def 		snake_case			(					self     ):






										"""simple docstring"""

										snake_case             =      DPTImageProcessor.from_pretrained('Intel/dpt-large'     )
										snake_case             =      DPTForDepthEstimation.from_pretrained('Intel/dpt-large'     ).to(lowerCAmelCase     )

										snake_case             =      prepare_img()
										snake_case             =      image_processor(images=lowerCAmelCase		,     return_tensors='pt'     ).to(lowerCAmelCase     )

										# forward pass
										with torch.no_grad():
																snake_case             =      model(**lowerCAmelCase     )
																snake_case             =      outputs.predicted_depth

										# verify the predicted depth
										snake_case             =      torch.Size((1, 3_84, 3_84)     )
										self.assertEqual(predicted_depth.shape		,     lowerCAmelCase     )

										snake_case             =      torch.tensor(
										    [[6.31_99, 6.36_29, 6.41_48], [6.38_50, 6.36_15, 6.41_66], [6.35_19, 6.31_76, 6.35_75]]     ).to(lowerCAmelCase     )

										self.assertTrue(torch.allclose(outputs.predicted_depth[0, :3, :3]		,     lowerCAmelCase		,     atol=1E-4     )     )

				def 		snake_case			(					self     ):






										"""simple docstring"""

										snake_case             =      DPTImageProcessor.from_pretrained('Intel/dpt-large-ade'     )
										snake_case             =      DPTForSemanticSegmentation.from_pretrained('Intel/dpt-large-ade'     ).to(lowerCAmelCase     )

										snake_case             =      prepare_img()
										snake_case             =      image_processor(images=lowerCAmelCase		,     return_tensors='pt'     ).to(lowerCAmelCase     )

										# forward pass
										with torch.no_grad():
																snake_case             =      model(**lowerCAmelCase     )

										# verify the logits
										snake_case             =      torch.Size((1, 1_50, 4_80, 4_80)     )
										self.assertEqual(outputs.logits.shape		,     lowerCAmelCase     )

										snake_case             =      torch.tensor(
										    [[4.04_80, 4.24_20, 4.43_60], [4.31_24, 4.56_93, 4.82_61], [4.57_68, 4.89_65, 5.21_63]]     ).to(lowerCAmelCase     )

										self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3]		,     lowerCAmelCase		,     atol=1E-4     )     )

				def 		snake_case			(					self     ):






										"""simple docstring"""

										snake_case             =      DPTImageProcessor.from_pretrained('Intel/dpt-large-ade'     )
										snake_case             =      DPTForSemanticSegmentation.from_pretrained('Intel/dpt-large-ade'     ).to(lowerCAmelCase     )

										snake_case             =      prepare_img()
										snake_case             =      image_processor(images=lowerCAmelCase		,     return_tensors='pt'     ).to(lowerCAmelCase     )

										# forward pass
										with torch.no_grad():
																snake_case             =      model(**lowerCAmelCase     )

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

										snake_case             =      image_processor.post_process_semantic_segmentation(outputs=lowerCAmelCase		,     target_sizes=[(5_00, 3_00)]     )
										snake_case             =      torch.Size((5_00, 3_00)     )
										self.assertEqual(segmentation[0].shape		,     lowerCAmelCase     )

										snake_case             =      image_processor.post_process_semantic_segmentation(outputs=lowerCAmelCase     )
										snake_case             =      torch.Size((4_80, 4_80)     )
										self.assertEqual(segmentation[0].shape		,     lowerCAmelCase     )


