


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 BeitImageProcessor
class 	lowerCamelCase_       (				unittest.TestCase				):



					'''simple docstring'''







					def __init__(				self ,       snake_case_ ,       snake_case_=7 ,       snake_case_=3 ,       snake_case_=1_8 ,       snake_case_=3_0 ,       snake_case_=4_0_0 ,       snake_case_=True ,       snake_case_=None ,       snake_case_=True ,       snake_case_=None ,       snake_case_=True ,       snake_case_=[0.5, 0.5, 0.5] ,       snake_case_=[0.5, 0.5, 0.5] ,       snake_case_=False ,       )   ->			Union[str, Any]:







								'''simple docstring'''

								__lowercase 					=   size if size is not None else {'''height''': 2_0, '''width''': 2_0}
								__lowercase 					=   crop_size if crop_size is not None else {'''height''': 1_8, '''width''': 1_8}
								__lowercase 					=   parent
								__lowercase 					=   batch_size
								__lowercase 					=   num_channels
								__lowercase 					=   image_size
								__lowercase 					=   min_resolution
								__lowercase 					=   max_resolution
								__lowercase 					=   do_resize
								__lowercase 					=   size
								__lowercase 					=   do_center_crop
								__lowercase 					=   crop_size
								__lowercase 					=   do_normalize
								__lowercase 					=   image_mean
								__lowercase 					=   image_std
								__lowercase 					=   do_reduce_labels






					def A      (				self						)   ->			Tuple:







								'''simple docstring'''

								return {
								    "do_resize": self.do_resize,
								    "size": self.size,
								    "do_center_crop": self.do_center_crop,
								    "crop_size": self.crop_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_  (     ):
			__lowercase 					=   load_dataset('''hf-internal-testing/fixtures_ade20k'''       ,			split='''test'''  )

			__lowercase 					=   Image.open(dataset[0]['''file''']  )
			__lowercase 					=   Image.open(dataset[1]['''file''']  )

			return image, map


def 		lowercase_  (     ):
			__lowercase 					=   load_dataset('''hf-internal-testing/fixtures_ade20k'''       ,			split='''test'''  )

			__lowercase 					=   Image.open(ds[0]['''file''']  )
			__lowercase 					=   Image.open(ds[1]['''file''']  )
			__lowercase 					=   Image.open(ds[2]['''file''']  )
			__lowercase 					=   Image.open(ds[3]['''file''']  )

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





@require_torch
@require_vision
class 	lowerCamelCase_       (				lowerCAmelCase__     ,     unittest.TestCase				):



					'''simple docstring'''







					__UpperCAmelCase            =				BeitImageProcessor if is_vision_available() else None






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







								'''simple docstring'''

								__lowercase 					=   BeitImageProcessingTester(self						)






					@property
					def A      (				self						)   ->			Any:







								'''simple docstring'''

								return self.image_processor_tester.prepare_image_processor_dict()






					def A      (				self						)   ->			int:







								'''simple docstring'''

								__lowercase 					=   self.image_processing_class(**self.image_processor_dict						)
								self.assertTrue(hasattr(snake_case_ ,       '''do_resize'''						)						)
								self.assertTrue(hasattr(snake_case_ ,       '''size'''						)						)
								self.assertTrue(hasattr(snake_case_ ,       '''do_center_crop'''						)						)
								self.assertTrue(hasattr(snake_case_ ,       '''center_crop'''						)						)
								self.assertTrue(hasattr(snake_case_ ,       '''do_normalize'''						)						)
								self.assertTrue(hasattr(snake_case_ ,       '''image_mean'''						)						)
								self.assertTrue(hasattr(snake_case_ ,       '''image_std'''						)						)






					def A      (				self						)   ->			str:







								'''simple docstring'''

								__lowercase 					=   self.image_processing_class.from_dict(self.image_processor_dict						)
								self.assertEqual(image_processor.size ,       {'''height''': 2_0, '''width''': 2_0}						)
								self.assertEqual(image_processor.crop_size ,       {'''height''': 1_8, '''width''': 1_8}						)
								self.assertEqual(image_processor.do_reduce_labels ,       snake_case_						)

								__lowercase 					=   self.image_processing_class.from_dict(
								    self.image_processor_dict ,       size=4_2 ,       crop_size=8_4 ,       reduce_labels=snake_case_						)
								self.assertEqual(image_processor.size ,       {'''height''': 4_2, '''width''': 4_2}						)
								self.assertEqual(image_processor.crop_size ,       {'''height''': 8_4, '''width''': 8_4}						)
								self.assertEqual(image_processor.do_reduce_labels ,       snake_case_						)






					def A      (				self						)   ->			Tuple:







								'''simple docstring'''

								pass






					def A      (				self						)   ->			int:







								'''simple docstring'''

								__lowercase 					=   self.image_processing_class(**self.image_processor_dict						)
								# create random PIL images
								__lowercase 					=   prepare_image_inputs(self.image_processor_tester ,       equal_resolution=snake_case_						)
								for image in image_inputs:
											self.assertIsInstance(snake_case_ ,       Image.Image						)

								# Test not batched input
								__lowercase 					=   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.crop_size['''height'''],
								        self.image_processor_tester.crop_size['''width'''],
								    ) ,       )

								# Test batched
								__lowercase 					=   image_processing(snake_case_ ,       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.crop_size['''height'''],
								        self.image_processor_tester.crop_size['''width'''],
								    ) ,       )






					def A      (				self						)   ->			str:







								'''simple docstring'''

								__lowercase 					=   self.image_processing_class(**self.image_processor_dict						)
								# create random numpy tensors
								__lowercase 					=   prepare_image_inputs(self.image_processor_tester ,       equal_resolution=snake_case_ ,       numpify=snake_case_						)
								for image in image_inputs:
											self.assertIsInstance(snake_case_ ,       np.ndarray						)

								# Test not batched input
								__lowercase 					=   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.crop_size['''height'''],
								        self.image_processor_tester.crop_size['''width'''],
								    ) ,       )

								# Test batched
								__lowercase 					=   image_processing(snake_case_ ,       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.crop_size['''height'''],
								        self.image_processor_tester.crop_size['''width'''],
								    ) ,       )






					def A      (				self						)   ->			int:







								'''simple docstring'''

								__lowercase 					=   self.image_processing_class(**self.image_processor_dict						)
								# create random PyTorch tensors
								__lowercase 					=   prepare_image_inputs(self.image_processor_tester ,       equal_resolution=snake_case_ ,       torchify=snake_case_						)
								for image in image_inputs:
											self.assertIsInstance(snake_case_ ,       torch.Tensor						)

								# Test not batched input
								__lowercase 					=   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.crop_size['''height'''],
								        self.image_processor_tester.crop_size['''width'''],
								    ) ,       )

								# Test batched
								__lowercase 					=   image_processing(snake_case_ ,       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.crop_size['''height'''],
								        self.image_processor_tester.crop_size['''width'''],
								    ) ,       )






					def A      (				self						)   ->			Tuple:







								'''simple docstring'''

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

								# Test not batched input
								__lowercase 					=   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.crop_size['''height'''],
								        self.image_processor_tester.crop_size['''width'''],
								    ) ,       )
								self.assertEqual(
								    encoding['''labels'''].shape ,       (
								        1,
								        self.image_processor_tester.crop_size['''height'''],
								        self.image_processor_tester.crop_size['''width'''],
								    ) ,       )
								self.assertEqual(encoding['''labels'''].dtype ,       torch.long						)
								self.assertTrue(encoding['''labels'''].min().item() >= 0						)
								self.assertTrue(encoding['''labels'''].max().item() <= 2_5_5						)

								# Test batched
								__lowercase 					=   image_processing(snake_case_ ,       snake_case_ ,       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.crop_size['''height'''],
								        self.image_processor_tester.crop_size['''width'''],
								    ) ,       )
								self.assertEqual(
								    encoding['''labels'''].shape ,       (
								        self.image_processor_tester.batch_size,
								        self.image_processor_tester.crop_size['''height'''],
								        self.image_processor_tester.crop_size['''width'''],
								    ) ,       )
								self.assertEqual(encoding['''labels'''].dtype ,       torch.long						)
								self.assertTrue(encoding['''labels'''].min().item() >= 0						)
								self.assertTrue(encoding['''labels'''].max().item() <= 2_5_5						)

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

								__lowercase 					=   image_processing(snake_case_ ,       snake_case_ ,       return_tensors='''pt'''						)
								self.assertEqual(
								    encoding['''pixel_values'''].shape ,       (
								        1,
								        self.image_processor_tester.num_channels,
								        self.image_processor_tester.crop_size['''height'''],
								        self.image_processor_tester.crop_size['''width'''],
								    ) ,       )
								self.assertEqual(
								    encoding['''labels'''].shape ,       (
								        1,
								        self.image_processor_tester.crop_size['''height'''],
								        self.image_processor_tester.crop_size['''width'''],
								    ) ,       )
								self.assertEqual(encoding['''labels'''].dtype ,       torch.long						)
								self.assertTrue(encoding['''labels'''].min().item() >= 0						)
								self.assertTrue(encoding['''labels'''].max().item() <= 2_5_5						)

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

								__lowercase 					=   image_processing(snake_case_ ,       snake_case_ ,       return_tensors='''pt'''						)
								self.assertEqual(
								    encoding['''pixel_values'''].shape ,       (
								        2,
								        self.image_processor_tester.num_channels,
								        self.image_processor_tester.crop_size['''height'''],
								        self.image_processor_tester.crop_size['''width'''],
								    ) ,       )
								self.assertEqual(
								    encoding['''labels'''].shape ,       (
								        2,
								        self.image_processor_tester.crop_size['''height'''],
								        self.image_processor_tester.crop_size['''width'''],
								    ) ,       )
								self.assertEqual(encoding['''labels'''].dtype ,       torch.long						)
								self.assertTrue(encoding['''labels'''].min().item() >= 0						)
								self.assertTrue(encoding['''labels'''].max().item() <= 2_5_5						)






					def A      (				self						)   ->			Dict:







								'''simple docstring'''

								__lowercase 					=   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
								__lowercase					, __lowercase 					=   prepare_semantic_single_inputs()
								__lowercase 					=   image_processing(snake_case_ ,       snake_case_ ,       return_tensors='''pt'''						)
								self.assertTrue(encoding['''labels'''].min().item() >= 0						)
								self.assertTrue(encoding['''labels'''].max().item() <= 1_5_0						)

								__lowercase 					=   True
								__lowercase 					=   image_processing(snake_case_ ,       snake_case_ ,       return_tensors='''pt'''						)
								self.assertTrue(encoding['''labels'''].min().item() >= 0						)
								self.assertTrue(encoding['''labels'''].max().item() <= 2_5_5						)






a : Any		=				'''
# Transformers 설치 방법
! pip install transformers datasets
# 마지막 릴리스 대신 소스에서 설치하려면, 위 명령을 주석으로 바꾸고 아래 명령을 해제하세요.
# ! pip install git+https://github.com/huggingface/transformers.git
'''

a : Union[str, Any]		=				[{'''type''': '''code''', '''content''': INSTALL_CONTENT}]
a : Union[str, Any]		=				{
    '''{processor_class}''': '''FakeProcessorClass''',
    '''{model_class}''': '''FakeModelClass''',
    '''{object_class}''': '''FakeObjectClass''',
}


