





'''simple docstring'''



import argparse
import os

import evaluate
import torch
from datasets import load_dataset
from torch.optim import AdamW
from torch.utils.data import DataLoader
from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed

from accelerate import Accelerator, DistributedType


########################################################################
# This is a fully working simple example to use Accelerate,
# specifically showcasing the checkpointing capability,
# and builds off the `nlp_example.py` script.
#
# This example trains a Bert base model on GLUE MRPC
# in any of the following settings (with the same script):
#   - single CPU or single GPU
#   - multi GPUS (using PyTorch distributed mode)
#   - (multi) TPUs
#   - fp16 (mixed-precision) or fp32 (normal precision)
#
# To help focus on the differences in the code, building `DataLoaders`
# was refactored into its own function.
# New additions from the base script can be found quickly by
# looking for the # New Code # tags
#
# To run it in each of these various modes, follow the instructions
# in the readme for examples:
# https://github.com/huggingface/accelerate/tree/main/examples
#
########################################################################

snake_case_   :  Union[str, Any]								=      16
snake_case_   :  Optional[int]								=      32



def  lowercase__(		_UpperCamelCase  : Accelerator ,   _UpperCamelCase  : int = 16				)->   Union[str, Any]:






					"""simple docstring"""

					_UpperCamelCase											=   AutoTokenizer.from_pretrained("bert-base-cased"				)
					_UpperCamelCase											=   load_dataset("glue" ,   "mrpc"				)

					def tokenize_function(_UpperCamelCase  : Optional[int]				):
										# max_length=None => use the model max length (it's actually the default)
										_UpperCamelCase											=   tokenizer(examples["sentence1"] ,   examples["sentence2"] ,   truncation=_UpperCamelCase ,   max_length=_UpperCamelCase				)
										return outputs

					# Apply the method we just defined to all the examples in all the splits of the dataset
					# starting with the main process first:
					with accelerator.main_process_first():
										_UpperCamelCase											=   datasets.map(
										    _UpperCamelCase ,   batched=_UpperCamelCase ,   remove_columns=["idx", "sentence1", "sentence2"] ,   )

					# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the
					# transformers library
					_UpperCamelCase											=   tokenized_datasets.rename_column("label" ,   "labels"				)

					def collate_fn(_UpperCamelCase  : Any				):
										# On TPU it's best to pad everything to the same length or training will be very slow.
										_UpperCamelCase											=   128 if accelerator.distributed_type == DistributedType.TPU else None
										# When using mixed precision we want round multiples of 8/16
										if accelerator.mixed_precision == "fp8":
															_UpperCamelCase											=   16
										elif accelerator.mixed_precision != "no":
															_UpperCamelCase											=   8
										else:
															_UpperCamelCase											=   None

										return tokenizer.pad(
										    _UpperCamelCase ,   padding="longest" ,   max_length=_UpperCamelCase ,   pad_to_multiple_of=_UpperCamelCase ,   return_tensors="pt" ,   )

					# Instantiate dataloaders.
					_UpperCamelCase											=   DataLoader(
					    tokenized_datasets["train"] ,   shuffle=_UpperCamelCase ,   collate_fn=_UpperCamelCase ,   batch_size=_UpperCamelCase				)
					_UpperCamelCase											=   DataLoader(
					    tokenized_datasets["validation"] ,   shuffle=_UpperCamelCase ,   collate_fn=_UpperCamelCase ,   batch_size=_UpperCamelCase				)

					return train_dataloader, eval_dataloader


# For testing only
if os.environ.get('''TESTING_MOCKED_DATALOADERS''', None) == "1":
			from accelerate.test_utils.training import mocked_dataloaders

			snake_case_   :  int								=      mocked_dataloaders  # noqa: F811



def  lowercase__(		_UpperCamelCase  : Any ,   _UpperCamelCase  : str				)->   List[str]:






					"""simple docstring"""

					if os.environ.get("TESTING_MOCKED_DATALOADERS" ,   _UpperCamelCase				) == "1":
										_UpperCamelCase											=   2
					# Initialize accelerator
					_UpperCamelCase											=   Accelerator(cpu=args.cpu ,   mixed_precision=args.mixed_precision				)
					# Sample hyper-parameters for learning rate, batch size, seed and a few other HPs
					_UpperCamelCase											=   config["lr"]
					_UpperCamelCase											=   int(config["num_epochs"]				)
					_UpperCamelCase											=   int(config["seed"]				)
					_UpperCamelCase											=   int(config["batch_size"]				)

					# New Code #
					# Parse out whether we are saving every epoch or after a certain number of batches
					if hasattr(args.checkpointing_steps ,   "isdigit"				):
										if args.checkpointing_steps == "epoch":
															_UpperCamelCase											=   args.checkpointing_steps
										elif args.checkpointing_steps.isdigit():
															_UpperCamelCase											=   int(args.checkpointing_steps				)
										else:
															raise ValueError(
															    f"Argument `checkpointing_steps` must be either a number or `epoch`. `{args.checkpointing_steps}` passed."				)
					else:
										_UpperCamelCase											=   None

					set_seed(_UpperCamelCase				)

					_UpperCamelCase				,	_UpperCamelCase											=   get_dataloaders(_UpperCamelCase ,   _UpperCamelCase				)
					_UpperCamelCase											=   evaluate.load("glue" ,   "mrpc"				)

					# If the batch size is too big we use gradient accumulation
					_UpperCamelCase											=   1
					if batch_size > MAX_GPU_BATCH_SIZE and accelerator.distributed_type != DistributedType.TPU:
										_UpperCamelCase											=   batch_size // MAX_GPU_BATCH_SIZE
										_UpperCamelCase											=   MAX_GPU_BATCH_SIZE

					# Instantiate the model (we build the model here so that the seed also control new weights initialization)
					_UpperCamelCase											=   AutoModelForSequenceClassification.from_pretrained("bert-base-cased" ,   return_dict=_UpperCamelCase				)

					# We could avoid this line since the accelerator is set with `device_placement=True` (default value).
					# Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer
					# creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that).
					_UpperCamelCase											=   model.to(accelerator.device				)

					# Instantiate optimizer
					_UpperCamelCase											=   AdamW(params=model.parameters() ,   lr=_UpperCamelCase				)

					# Instantiate scheduler
					_UpperCamelCase											=   get_linear_schedule_with_warmup(
					    optimizer=_UpperCamelCase ,   num_warmup_steps=100 ,   num_training_steps=(len(_UpperCamelCase				) * num_epochs) // gradient_accumulation_steps ,   )

					# Prepare everything
					# There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the
					# prepare method.
					_UpperCamelCase				,	_UpperCamelCase				,	_UpperCamelCase				,	_UpperCamelCase				,	_UpperCamelCase											=   accelerator.prepare(
					    _UpperCamelCase ,   _UpperCamelCase ,   _UpperCamelCase ,   _UpperCamelCase ,   _UpperCamelCase				)

					# New Code #
					# We need to keep track of how many total steps we have iterated over
					_UpperCamelCase											=   0
					# We also need to keep track of the stating epoch so files are named properly
					_UpperCamelCase											=   0

					# We need to load the checkpoint back in before training here with `load_state`
					# The total number of epochs is adjusted based on where the state is being loaded from,
					# as we assume continuation of the same training script
					if args.resume_from_checkpoint:
										if args.resume_from_checkpoint is not None or args.resume_from_checkpoint != "":
															accelerator.print(f"Resumed from checkpoint: {args.resume_from_checkpoint}"				)
															accelerator.load_state(args.resume_from_checkpoint				)
															_UpperCamelCase											=   os.path.basename(args.resume_from_checkpoint				)
										else:
															# Get the most recent checkpoint
															_UpperCamelCase											=   [f.name for f in os.scandir(os.getcwd()				) if f.is_dir()]
															dirs.sort(key=os.path.getctime				)
															_UpperCamelCase											=   dirs[-1]  # Sorts folders by date modified, most recent checkpoint is the last
										# Extract `epoch_{i}` or `step_{i}`
										_UpperCamelCase											=   os.path.splitext(_UpperCamelCase				)[0]

										if "epoch" in training_difference:
															_UpperCamelCase											=   int(training_difference.replace("epoch_" ,   ""				)				) + 1
															_UpperCamelCase											=   None
										else:
															_UpperCamelCase											=   int(training_difference.replace("step_" ,   ""				)				)
															_UpperCamelCase											=   resume_step // len(_UpperCamelCase				)
															resume_step -= starting_epoch * len(_UpperCamelCase				)

    # Now we train the model
					for epoch in range(_UpperCamelCase ,   _UpperCamelCase				):
										model.train()
										# New Code #
										if args.resume_from_checkpoint and epoch == starting_epoch and resume_step is not None:
															# We need to skip steps until we reach the resumed step
															_UpperCamelCase											=   accelerator.skip_first_batches(_UpperCamelCase ,   _UpperCamelCase				)
															overall_step += resume_step
										else:
															# After the first iteration though, we need to go back to the original dataloader
															_UpperCamelCase											=   train_dataloader
										for step, batch in enumerate(_UpperCamelCase				):
															# We could avoid this line since we set the accelerator with `device_placement=True`.
															batch.to(accelerator.device				)
															_UpperCamelCase											=   model(**_UpperCamelCase				)
															_UpperCamelCase											=   outputs.loss
															_UpperCamelCase											=   loss / gradient_accumulation_steps
															accelerator.backward(_UpperCamelCase				)
															if step % gradient_accumulation_steps == 0:
																				optimizer.step()
																				lr_scheduler.step()
																				optimizer.zero_grad()
															# New Code #
															overall_step += 1

															# New Code #
															# We save the model, optimizer, lr_scheduler, and seed states by calling `save_state`
															# These are saved to folders named `step_{overall_step}`
															# Will contain files: "pytorch_model.bin", "optimizer.bin", "scheduler.bin", and "random_states.pkl"
															# If mixed precision was used, will also save a "scalar.bin" file
															if isinstance(_UpperCamelCase ,   _UpperCamelCase				):
																				_UpperCamelCase											=   f"step_{overall_step}"
																				if overall_step % checkpointing_steps == 0:
																									if args.output_dir is not None:
																														_UpperCamelCase											=   os.path.join(args.output_dir ,   _UpperCamelCase				)
																									accelerator.save_state(_UpperCamelCase				)

										model.eval()
										for step, batch in enumerate(_UpperCamelCase				):
															# We could avoid this line since we set the accelerator with `device_placement=True` (the default).
															batch.to(accelerator.device				)
															with torch.no_grad():
																				_UpperCamelCase											=   model(**_UpperCamelCase				)
															_UpperCamelCase											=   outputs.logits.argmax(dim=-1				)
															_UpperCamelCase				,	_UpperCamelCase											=   accelerator.gather_for_metrics((predictions, batch["labels"])				)
															metric.add_batch(
															    predictions=_UpperCamelCase ,   references=_UpperCamelCase ,   )

										_UpperCamelCase											=   metric.compute()
										# Use accelerator.print to print only on the main process.
										accelerator.print(f"epoch {epoch}:" ,   _UpperCamelCase				)

										# New Code #
										# We save the model, optimizer, lr_scheduler, and seed states by calling `save_state`
										# These are saved to folders named `epoch_{epoch}`
										# Will contain files: "pytorch_model.bin", "optimizer.bin", "scheduler.bin", and "random_states.pkl"
										# If mixed precision was used, will also save a "scalar.bin" file
										if checkpointing_steps == "epoch":
															_UpperCamelCase											=   f"epoch_{epoch}"
															if args.output_dir is not None:
																				_UpperCamelCase											=   os.path.join(args.output_dir ,   _UpperCamelCase				)
															accelerator.save_state(_UpperCamelCase				)



def  lowercase__(		)->   Any:






					"""simple docstring"""

					_UpperCamelCase											=   argparse.ArgumentParser(description="Simple example of training script."				)
					parser.add_argument(
					    "--mixed_precision" ,   type=_UpperCamelCase ,   default=_UpperCamelCase ,   choices=["no", "fp16", "bf16", "fp8"] ,   help="Whether to use mixed precision. Choose"
					    "between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10."
					    "and an Nvidia Ampere GPU." ,   )
					parser.add_argument("--cpu" ,   action="store_true" ,   help="If passed, will train on the CPU."				)
					parser.add_argument(
					    "--checkpointing_steps" ,   type=_UpperCamelCase ,   default=_UpperCamelCase ,   help="Whether the various states should be saved at the end of every n steps, or 'epoch' for each epoch." ,   )
					parser.add_argument(
					    "--output_dir" ,   type=_UpperCamelCase ,   default="." ,   help="Optional save directory where all checkpoint folders will be stored. Default is the current working directory." ,   )
					parser.add_argument(
					    "--resume_from_checkpoint" ,   type=_UpperCamelCase ,   default=_UpperCamelCase ,   help="If the training should continue from a checkpoint folder." ,   )
					_UpperCamelCase											=   parser.parse_args()
					_UpperCamelCase											=   {"lr": 2E-5, "num_epochs": 3, "seed": 42, "batch_size": 16}
					training_function(_UpperCamelCase ,   _UpperCamelCase				)


if __name__ == "__main__":
			main()










'''simple docstring'''



import unittest

import numpy as np
from datasets import load_dataset

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
			import torch

if is_vision_available():
			from PIL import Image

			from transformers import SegformerImageProcessor

class     A_ (  unittest.TestCase  ):

			'''simple docstring'''





			def __init__(					self			,     A_			,     A_=7			,     A_=3			,     A_=30			,     A_=4_00			,     A_=True			,     A_=None			,     A_=True			,     A_=[0.5, 0.5, 0.5]			,     A_=[0.5, 0.5, 0.5]			,     A_=False			,     ):
								_UpperCamelCase											=   size if size is not None else {"height": 30, "width": 30}
								_UpperCamelCase											=   parent
								_UpperCamelCase											=   batch_size
								_UpperCamelCase											=   num_channels
								_UpperCamelCase											=   min_resolution
								_UpperCamelCase											=   max_resolution
								_UpperCamelCase											=   do_resize
								_UpperCamelCase											=   size
								_UpperCamelCase											=   do_normalize
								_UpperCamelCase											=   image_mean
								_UpperCamelCase											=   image_std
								_UpperCamelCase											=   do_reduce_labels




			def       a	(					self   ):
								return {
								    "do_resize": self.do_resize,
								    "size": self.size,
								    "do_normalize": self.do_normalize,
								    "image_mean": self.image_mean,
								    "image_std": self.image_std,
								    "do_reduce_labels": self.do_reduce_labels,
								}




def  lowercase__(		)->   Dict:






					"""simple docstring"""

					_UpperCamelCase											=   load_dataset("hf-internal-testing/fixtures_ade20k" ,   split="test"				)

					_UpperCamelCase											=   Image.open(dataset[0]["file"]				)
					_UpperCamelCase											=   Image.open(dataset[1]["file"]				)

					return image, map



def  lowercase__(		)->   Dict:






					"""simple docstring"""

					_UpperCamelCase											=   load_dataset("hf-internal-testing/fixtures_ade20k" ,   split="test"				)

					_UpperCamelCase											=   Image.open(dataset[0]["file"]				)
					_UpperCamelCase											=   Image.open(dataset[1]["file"]				)
					_UpperCamelCase											=   Image.open(dataset[2]["file"]				)
					_UpperCamelCase											=   Image.open(dataset[3]["file"]				)

					return [imagea, imagea], [mapa, mapa]

@require_torch
@require_vision
class     A_ (  lowerCAmelCase_    ,			unittest.TestCase  ):

			'''simple docstring'''





			_lowerCAmelCase						=    SegformerImageProcessor if is_vision_available() else None




			def       a	(					self   ):
								_UpperCamelCase											=   SegformerImageProcessingTester(self   )




			@property
			def       a	(					self   ):
								return self.image_processor_tester.prepare_image_processor_dict()




			def       a	(					self   ):
								_UpperCamelCase											=   self.image_processing_class(**self.image_processor_dict   )
								self.assertTrue(hasattr(A_			,     "do_resize"   )   )
								self.assertTrue(hasattr(A_			,     "size"   )   )
								self.assertTrue(hasattr(A_			,     "do_normalize"   )   )
								self.assertTrue(hasattr(A_			,     "image_mean"   )   )
								self.assertTrue(hasattr(A_			,     "image_std"   )   )
								self.assertTrue(hasattr(A_			,     "do_reduce_labels"   )   )




			def       a	(					self   ):
								_UpperCamelCase											=   self.image_processing_class.from_dict(self.image_processor_dict   )
								self.assertEqual(image_processor.size			,     {"height": 30, "width": 30}   )
								self.assertEqual(image_processor.do_reduce_labels			,     A_   )

								_UpperCamelCase											=   self.image_processing_class.from_dict(self.image_processor_dict			,     size=42			,     reduce_labels=A_   )
								self.assertEqual(image_processor.size			,     {"height": 42, "width": 42}   )
								self.assertEqual(image_processor.do_reduce_labels			,     A_   )




			def       a	(					self   ):
								pass




			def       a	(					self   ):
								# Initialize image_processing
								_UpperCamelCase											=   self.image_processing_class(**self.image_processor_dict   )
								# create random PIL images
								_UpperCamelCase											=   prepare_image_inputs(self.image_processor_tester			,     equal_resolution=A_   )
								for image in image_inputs:
													self.assertIsInstance(A_			,     Image.Image   )

								# Test not batched input
								_UpperCamelCase											=   image_processing(image_inputs[0]			,     return_tensors="pt"   ).pixel_values
								self.assertEqual(
								    encoded_images.shape			,     (
								        1,
								        self.image_processor_tester.num_channels,
								        self.image_processor_tester.size["height"],
								        self.image_processor_tester.size["width"],
								    )			,     )

								# Test batched
								_UpperCamelCase											=   image_processing(A_			,     return_tensors="pt"   ).pixel_values
								self.assertEqual(
								    encoded_images.shape			,     (
								        self.image_processor_tester.batch_size,
								        self.image_processor_tester.num_channels,
								        self.image_processor_tester.size["height"],
								        self.image_processor_tester.size["width"],
								    )			,     )




			def       a	(					self   ):
								# Initialize image_processing
								_UpperCamelCase											=   self.image_processing_class(**self.image_processor_dict   )
								# create random numpy tensors
								_UpperCamelCase											=   prepare_image_inputs(self.image_processor_tester			,     equal_resolution=A_			,     numpify=A_   )
								for image in image_inputs:
													self.assertIsInstance(A_			,     np.ndarray   )

								# Test not batched input
								_UpperCamelCase											=   image_processing(image_inputs[0]			,     return_tensors="pt"   ).pixel_values
								self.assertEqual(
								    encoded_images.shape			,     (
								        1,
								        self.image_processor_tester.num_channels,
								        self.image_processor_tester.size["height"],
								        self.image_processor_tester.size["width"],
								    )			,     )

								# Test batched
								_UpperCamelCase											=   image_processing(A_			,     return_tensors="pt"   ).pixel_values
								self.assertEqual(
								    encoded_images.shape			,     (
								        self.image_processor_tester.batch_size,
								        self.image_processor_tester.num_channels,
								        self.image_processor_tester.size["height"],
								        self.image_processor_tester.size["width"],
								    )			,     )




			def       a	(					self   ):
								# Initialize image_processing
								_UpperCamelCase											=   self.image_processing_class(**self.image_processor_dict   )
								# create random PyTorch tensors
								_UpperCamelCase											=   prepare_image_inputs(self.image_processor_tester			,     equal_resolution=A_			,     torchify=A_   )
								for image in image_inputs:
													self.assertIsInstance(A_			,     torch.Tensor   )

								# Test not batched input
								_UpperCamelCase											=   image_processing(image_inputs[0]			,     return_tensors="pt"   ).pixel_values
								self.assertEqual(
								    encoded_images.shape			,     (
								        1,
								        self.image_processor_tester.num_channels,
								        self.image_processor_tester.size["height"],
								        self.image_processor_tester.size["width"],
								    )			,     )

								# Test batched
								_UpperCamelCase											=   image_processing(A_			,     return_tensors="pt"   ).pixel_values
								self.assertEqual(
								    encoded_images.shape			,     (
								        self.image_processor_tester.batch_size,
								        self.image_processor_tester.num_channels,
								        self.image_processor_tester.size["height"],
								        self.image_processor_tester.size["width"],
								    )			,     )




			def       a	(					self   ):
								# Initialize image_processing
								_UpperCamelCase											=   self.image_processing_class(**self.image_processor_dict   )
								# create random PyTorch tensors
								_UpperCamelCase											=   prepare_image_inputs(self.image_processor_tester			,     equal_resolution=A_			,     torchify=A_   )
								_UpperCamelCase											=   []
								for image in image_inputs:
													self.assertIsInstance(A_			,     torch.Tensor   )
													maps.append(torch.zeros(image.shape[-2:]   ).long()   )

								# Test not batched input
								_UpperCamelCase											=   image_processing(image_inputs[0]			,     maps[0]			,     return_tensors="pt"   )
								self.assertEqual(
								    encoding["pixel_values"].shape			,     (
								        1,
								        self.image_processor_tester.num_channels,
								        self.image_processor_tester.size["height"],
								        self.image_processor_tester.size["width"],
								    )			,     )
								self.assertEqual(
								    encoding["labels"].shape			,     (
								        1,
								        self.image_processor_tester.size["height"],
								        self.image_processor_tester.size["width"],
								    )			,     )
								self.assertEqual(encoding["labels"].dtype			,     torch.long   )
								self.assertTrue(encoding["labels"].min().item() >= 0   )
								self.assertTrue(encoding["labels"].max().item() <= 2_55   )

								# Test batched
								_UpperCamelCase											=   image_processing(A_			,     A_			,     return_tensors="pt"   )
								self.assertEqual(
								    encoding["pixel_values"].shape			,     (
								        self.image_processor_tester.batch_size,
								        self.image_processor_tester.num_channels,
								        self.image_processor_tester.size["height"],
								        self.image_processor_tester.size["width"],
								    )			,     )
								self.assertEqual(
								    encoding["labels"].shape			,     (
								        self.image_processor_tester.batch_size,
								        self.image_processor_tester.size["height"],
								        self.image_processor_tester.size["width"],
								    )			,     )
								self.assertEqual(encoding["labels"].dtype			,     torch.long   )
								self.assertTrue(encoding["labels"].min().item() >= 0   )
								self.assertTrue(encoding["labels"].max().item() <= 2_55   )

								# Test not batched input (PIL images)
								_UpperCamelCase				,	_UpperCamelCase											=   prepare_semantic_single_inputs()

								_UpperCamelCase											=   image_processing(A_			,     A_			,     return_tensors="pt"   )
								self.assertEqual(
								    encoding["pixel_values"].shape			,     (
								        1,
								        self.image_processor_tester.num_channels,
								        self.image_processor_tester.size["height"],
								        self.image_processor_tester.size["width"],
								    )			,     )
								self.assertEqual(
								    encoding["labels"].shape			,     (
								        1,
								        self.image_processor_tester.size["height"],
								        self.image_processor_tester.size["width"],
								    )			,     )
								self.assertEqual(encoding["labels"].dtype			,     torch.long   )
								self.assertTrue(encoding["labels"].min().item() >= 0   )
								self.assertTrue(encoding["labels"].max().item() <= 2_55   )

								# Test batched input (PIL images)
								_UpperCamelCase				,	_UpperCamelCase											=   prepare_semantic_batch_inputs()

								_UpperCamelCase											=   image_processing(A_			,     A_			,     return_tensors="pt"   )
								self.assertEqual(
								    encoding["pixel_values"].shape			,     (
								        2,
								        self.image_processor_tester.num_channels,
								        self.image_processor_tester.size["height"],
								        self.image_processor_tester.size["width"],
								    )			,     )
								self.assertEqual(
								    encoding["labels"].shape			,     (
								        2,
								        self.image_processor_tester.size["height"],
								        self.image_processor_tester.size["width"],
								    )			,     )
								self.assertEqual(encoding["labels"].dtype			,     torch.long   )
								self.assertTrue(encoding["labels"].min().item() >= 0   )
								self.assertTrue(encoding["labels"].max().item() <= 2_55   )




			def       a	(					self   ):
								# Initialize image_processing
								_UpperCamelCase											=   self.image_processing_class(**self.image_processor_dict   )

								# ADE20k has 150 classes, and the background is included, so labels should be between 0 and 150
								_UpperCamelCase				,	_UpperCamelCase											=   prepare_semantic_single_inputs()
								_UpperCamelCase											=   image_processing(A_			,     A_			,     return_tensors="pt"   )
								self.assertTrue(encoding["labels"].min().item() >= 0   )
								self.assertTrue(encoding["labels"].max().item() <= 1_50   )

								_UpperCamelCase											=   True
								_UpperCamelCase											=   image_processing(A_			,     A_			,     return_tensors="pt"   )
								self.assertTrue(encoding["labels"].min().item() >= 0   )
								self.assertTrue(encoding["labels"].max().item() <= 2_55   )



