




import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import BertTokenizer, BertTokenizerFast
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
					from PIL import Image

					from transformers import AlignProcessor, EfficientNetImageProcessor







@require_vision
class        __lowerCAmelCase					(			unittest.TestCase					):

			"""simple docstring"""







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



							'''simple docstring'''
							__lowerCamelCase									=       tempfile.mkdtemp()

							__lowerCamelCase									=       [
							    '[UNK]',
							    '[CLS]',
							    '[SEP]',
							    '[PAD]',
							    '[MASK]',
							    'want',
							    '##want',
							    '##ed',
							    'wa',
							    'un',
							    'runn',
							    '##ing',
							    ',',
							    'low',
							    'lowest',
							]
							__lowerCamelCase									=       os.path.join(self.tmpdirname     ,		VOCAB_FILES_NAMES['vocab_file']				)
							with open(self.vocab_file     ,		'w'     ,		encoding='utf-8'				) as vocab_writer:
											vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]				)				)

							__lowerCamelCase									=       {
							    'do_resize': True,
							    'size': 20,
							    'do_center_crop': True,
							    'crop_size': 18,
							    'do_normalize': True,
							    'image_mean': [0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73],
							    'image_std': [0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11],
							}
							__lowerCamelCase									=       os.path.join(self.tmpdirname     ,		lowerCamelCase__				)
							with open(self.image_processor_file     ,		'w'     ,		encoding='utf-8'				) as fp:
											json.dump(lowerCamelCase__     ,		lowerCamelCase__				)


			def  lowercase_       ( self     ,		**lowerCamelCase__				)       -> Tuple:



							'''simple docstring'''
							return BertTokenizer.from_pretrained(self.tmpdirname     ,		**lowerCamelCase__				)


			def  lowercase_       ( self     ,		**lowerCamelCase__				)       -> str:



							'''simple docstring'''
							return BertTokenizerFast.from_pretrained(self.tmpdirname     ,		**lowerCamelCase__				)


			def  lowercase_       ( self     ,		**lowerCamelCase__				)       -> Tuple:



							'''simple docstring'''
							return EfficientNetImageProcessor.from_pretrained(self.tmpdirname     ,		**lowerCamelCase__				)


			def  lowercase_       ( self				)       -> Tuple:



							'''simple docstring'''
							shutil.rmtree(self.tmpdirname				)


			def  lowercase_       ( self				)       -> str:



							'''simple docstring'''
							__lowerCamelCase									=       [np.random.randint(255     ,		size=(3, 30, 400)     ,		dtype=np.uinta				)]
							__lowerCamelCase									=       [Image.fromarray(np.moveaxis(lowerCamelCase__     ,		0     ,		-1				)				) for x in image_inputs]
							return image_inputs


			def  lowercase_       ( self				)       -> int:



							'''simple docstring'''
							__lowerCamelCase									=       self.get_tokenizer()
							__lowerCamelCase									=       self.get_rust_tokenizer()
							__lowerCamelCase									=       self.get_image_processor()

							__lowerCamelCase									=       AlignProcessor(tokenizer=lowerCamelCase__     ,		image_processor=lowerCamelCase__				)
							processor_slow.save_pretrained(self.tmpdirname				)
							__lowerCamelCase									=       AlignProcessor.from_pretrained(self.tmpdirname     ,		use_fast=lowerCamelCase__				)

							__lowerCamelCase									=       AlignProcessor(tokenizer=lowerCamelCase__     ,		image_processor=lowerCamelCase__				)
							processor_fast.save_pretrained(self.tmpdirname				)
							__lowerCamelCase									=       AlignProcessor.from_pretrained(self.tmpdirname				)

							self.assertEqual(processor_slow.tokenizer.get_vocab()     ,		tokenizer_slow.get_vocab()				)
							self.assertEqual(processor_fast.tokenizer.get_vocab()     ,		tokenizer_fast.get_vocab()				)
							self.assertEqual(tokenizer_slow.get_vocab()     ,		tokenizer_fast.get_vocab()				)
							self.assertIsInstance(processor_slow.tokenizer     ,		lowerCamelCase__				)
							self.assertIsInstance(processor_fast.tokenizer     ,		lowerCamelCase__				)

							self.assertEqual(processor_slow.image_processor.to_json_string()     ,		image_processor.to_json_string()				)
							self.assertEqual(processor_fast.image_processor.to_json_string()     ,		image_processor.to_json_string()				)
							self.assertIsInstance(processor_slow.image_processor     ,		lowerCamelCase__				)
							self.assertIsInstance(processor_fast.image_processor     ,		lowerCamelCase__				)


			def  lowercase_       ( self				)       -> Any:



							'''simple docstring'''
							__lowerCamelCase									=       AlignProcessor(tokenizer=self.get_tokenizer()     ,		image_processor=self.get_image_processor()				)
							processor.save_pretrained(self.tmpdirname				)

							__lowerCamelCase									=       self.get_tokenizer(bos_token='(BOS)'     ,		eos_token='(EOS)'				)
							__lowerCamelCase									=       self.get_image_processor(do_normalize=lowerCamelCase__     ,		padding_value=1.0				)

							__lowerCamelCase									=       AlignProcessor.from_pretrained(
							    self.tmpdirname     ,		bos_token='(BOS)'     ,		eos_token='(EOS)'     ,		do_normalize=lowerCamelCase__     ,		padding_value=1.0				)

							self.assertEqual(processor.tokenizer.get_vocab()     ,		tokenizer_add_kwargs.get_vocab()				)
							self.assertIsInstance(processor.tokenizer     ,		lowerCamelCase__				)

							self.assertEqual(processor.image_processor.to_json_string()     ,		image_processor_add_kwargs.to_json_string()				)
							self.assertIsInstance(processor.image_processor     ,		lowerCamelCase__				)


			def  lowercase_       ( self				)       -> str:



							'''simple docstring'''
							__lowerCamelCase									=       self.get_image_processor()
							__lowerCamelCase									=       self.get_tokenizer()

							__lowerCamelCase									=       AlignProcessor(tokenizer=lowerCamelCase__     ,		image_processor=lowerCamelCase__				)

							__lowerCamelCase									=       self.prepare_image_inputs()

							__lowerCamelCase									=       image_processor(lowerCamelCase__     ,		return_tensors='np'				)
							__lowerCamelCase									=       processor(images=lowerCamelCase__     ,		return_tensors='np'				)

							for key in input_image_proc.keys():
											self.assertAlmostEqual(input_image_proc[key].sum()     ,		input_processor[key].sum()     ,		delta=1e-2				)


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



							'''simple docstring'''
							__lowerCamelCase									=       self.get_image_processor()
							__lowerCamelCase									=       self.get_tokenizer()

							__lowerCamelCase									=       AlignProcessor(tokenizer=lowerCamelCase__     ,		image_processor=lowerCamelCase__				)

							__lowerCamelCase									=       'lower newer'

							__lowerCamelCase									=       processor(text=lowerCamelCase__				)

							__lowerCamelCase									=       tokenizer(lowerCamelCase__     ,		padding='max_length'     ,		max_length=64				)

							for key in encoded_tok.keys():
											self.assertListEqual(encoded_tok[key]     ,		encoded_processor[key]				)


			def  lowercase_       ( self				)       -> Dict:



							'''simple docstring'''
							__lowerCamelCase									=       self.get_image_processor()
							__lowerCamelCase									=       self.get_tokenizer()

							__lowerCamelCase									=       AlignProcessor(tokenizer=lowerCamelCase__     ,		image_processor=lowerCamelCase__				)

							__lowerCamelCase									=       'lower newer'
							__lowerCamelCase									=       self.prepare_image_inputs()

							__lowerCamelCase									=       processor(text=lowerCamelCase__     ,		images=lowerCamelCase__				)

							self.assertListEqual(list(inputs.keys()				)     ,		['input_ids', 'token_type_ids', 'attention_mask', 'pixel_values']				)

							# test if it raises when no input is passed
							with pytest.raises(lowerCamelCase__				):
											processor()


			def  lowercase_       ( self				)       -> str:



							'''simple docstring'''
							__lowerCamelCase									=       self.get_image_processor()
							__lowerCamelCase									=       self.get_tokenizer()

							__lowerCamelCase									=       AlignProcessor(tokenizer=lowerCamelCase__     ,		image_processor=lowerCamelCase__				)

							__lowerCamelCase									=       [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

							__lowerCamelCase									=       processor.batch_decode(lowerCamelCase__				)
							__lowerCamelCase									=       tokenizer.batch_decode(lowerCamelCase__				)

							self.assertListEqual(lowerCamelCase__     ,		lowerCamelCase__				)






			def  lowercase_       ( self				)       -> List[Any]:



							'''simple docstring'''
							__lowerCamelCase									=       self.get_image_processor()
							__lowerCamelCase									=       self.get_tokenizer()

							__lowerCamelCase									=       AlignProcessor(tokenizer=lowerCamelCase__     ,		image_processor=lowerCamelCase__				)

							__lowerCamelCase									=       'lower newer'
							__lowerCamelCase									=       self.prepare_image_inputs()

							__lowerCamelCase									=       processor(text=lowerCamelCase__     ,		images=lowerCamelCase__				)

							self.assertListEqual(list(inputs.keys()				)     ,		processor.model_input_names				)








from typing import Dict, List, Optional, Tuple, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_torch_available, is_torch_tensor, logging


if is_torch_available():
					import torch


__A								=       logging.get_logger(__name__)







class        __lowerCAmelCase					(			__magic_name__					):

			"""simple docstring"""







			snake_case_  						=			['''pixel_values''']


			def __init__( self     ,		lowerCamelCase__ = True     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = PILImageResampling.BILINEAR     ,		lowerCamelCase__ = True     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = True     ,		lowerCamelCase__ = 1 / 255     ,		lowerCamelCase__ = True     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = None     ,		**lowerCamelCase__     ,		)       -> None:



							'''simple docstring'''
							super().__init__(**lowerCamelCase__				)
							__lowerCamelCase									=       size if size is not None else {'shortest_edge': 256}
							__lowerCamelCase									=       get_size_dict(lowerCamelCase__     ,		default_to_square=lowerCamelCase__				)
							__lowerCamelCase									=       crop_size if crop_size is not None else {'height': 224, 'width': 224}
							__lowerCamelCase									=       get_size_dict(lowerCamelCase__     ,		param_name='crop_size'				)
							__lowerCamelCase									=       do_resize
							__lowerCamelCase									=       size
							__lowerCamelCase									=       resample
							__lowerCamelCase									=       do_center_crop
							__lowerCamelCase									=       crop_size
							__lowerCamelCase									=       do_rescale
							__lowerCamelCase									=       rescale_factor
							__lowerCamelCase									=       do_normalize
							__lowerCamelCase									=       image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
							__lowerCamelCase									=       image_std if image_std is not None else IMAGENET_STANDARD_STD


			def  lowercase_       ( self     ,		lowerCamelCase__     ,		lowerCamelCase__     ,		lowerCamelCase__ = PILImageResampling.BICUBIC     ,		lowerCamelCase__ = None     ,		**lowerCamelCase__     ,		)       -> np.ndarray:



							'''simple docstring'''
							__lowerCamelCase									=       get_size_dict(lowerCamelCase__     ,		default_to_square=lowerCamelCase__				)
							if "shortest_edge" not in size:
											raise ValueError(f"""The `size` parameter must contain the key `shortest_edge`. Got {size.keys()}"""				)
							__lowerCamelCase									=       get_resize_output_image_size(lowerCamelCase__     ,		size=size['shortest_edge']     ,		default_to_square=lowerCamelCase__				)
							return resize(lowerCamelCase__     ,		size=lowerCamelCase__     ,		resample=lowerCamelCase__     ,		data_format=lowerCamelCase__     ,		**lowerCamelCase__				)


			def  lowercase_       ( self     ,		lowerCamelCase__     ,		lowerCamelCase__     ,		lowerCamelCase__ = None     ,		**lowerCamelCase__     ,		)       -> np.ndarray:



							'''simple docstring'''
							__lowerCamelCase									=       get_size_dict(lowerCamelCase__				)
							if "height" not in size or "width" not in size:
											raise ValueError(f"""The `size` parameter must contain the keys `height` and `width`. Got {size.keys()}"""				)
							return center_crop(lowerCamelCase__     ,		size=(size['height'], size['width'])     ,		data_format=lowerCamelCase__     ,		**lowerCamelCase__				)


			def  lowercase_       ( self     ,		lowerCamelCase__     ,		lowerCamelCase__     ,		lowerCamelCase__ = None     ,		**lowerCamelCase__				)       -> np.ndarray:



							'''simple docstring'''
							return rescale(lowerCamelCase__     ,		scale=lowerCamelCase__     ,		data_format=lowerCamelCase__     ,		**lowerCamelCase__				)


			def  lowercase_       ( self     ,		lowerCamelCase__     ,		lowerCamelCase__     ,		lowerCamelCase__     ,		lowerCamelCase__ = None     ,		**lowerCamelCase__     ,		)       -> np.ndarray:



							'''simple docstring'''
							return normalize(lowerCamelCase__     ,		mean=lowerCamelCase__     ,		std=lowerCamelCase__     ,		data_format=lowerCamelCase__     ,		**lowerCamelCase__				)


			def  lowercase_       ( self     ,		lowerCamelCase__     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = ChannelDimension.FIRST     ,		**lowerCamelCase__     ,		)       -> str:



							'''simple docstring'''
							__lowerCamelCase									=       do_resize if do_resize is not None else self.do_resize
							__lowerCamelCase									=       size if size is not None else self.size
							__lowerCamelCase									=       get_size_dict(lowerCamelCase__     ,		default_to_square=lowerCamelCase__				)
							__lowerCamelCase									=       resample if resample is not None else self.resample
							__lowerCamelCase									=       do_center_crop if do_center_crop is not None else self.do_center_crop
							__lowerCamelCase									=       crop_size if crop_size is not None else self.crop_size
							__lowerCamelCase									=       get_size_dict(lowerCamelCase__     ,		param_name='crop_size'				)
							__lowerCamelCase									=       do_rescale if do_rescale is not None else self.do_rescale
							__lowerCamelCase									=       rescale_factor if rescale_factor is not None else self.rescale_factor
							__lowerCamelCase									=       do_normalize if do_normalize is not None else self.do_normalize
							__lowerCamelCase									=       image_mean if image_mean is not None else self.image_mean
							__lowerCamelCase									=       image_std if image_std is not None else self.image_std

							__lowerCamelCase									=       make_list_of_images(lowerCamelCase__				)

							if not valid_images(lowerCamelCase__				):
											raise ValueError(
											    'Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '
											    'torch.Tensor, tf.Tensor or jax.ndarray.'				)

							if do_resize and size is None:
											raise ValueError('Size must be specified if do_resize is True.'				)

							if do_center_crop and crop_size is None:
											raise ValueError('Crop size must be specified if do_center_crop is True.'				)

							if do_rescale and rescale_factor is None:
											raise ValueError('Rescale factor must be specified if do_rescale is True.'				)

							if do_normalize and (image_mean is None or image_std is None):
											raise ValueError('Image mean and std must be specified if do_normalize is True.'				)

							# All transformations expect numpy arrays.
							__lowerCamelCase									=       [to_numpy_array(lowerCamelCase__				) for image in images]

							if do_resize:
											__lowerCamelCase									=       [self.resize(image=lowerCamelCase__     ,		size=lowerCamelCase__     ,		resample=lowerCamelCase__				) for image in images]

							if do_center_crop:
											__lowerCamelCase									=       [self.center_crop(image=lowerCamelCase__     ,		size=lowerCamelCase__				) for image in images]

							if do_rescale:
											__lowerCamelCase									=       [self.rescale(image=lowerCamelCase__     ,		scale=lowerCamelCase__				) for image in images]

							if do_normalize:
											__lowerCamelCase									=       [self.normalize(image=lowerCamelCase__     ,		mean=lowerCamelCase__     ,		std=lowerCamelCase__				) for image in images]

							__lowerCamelCase									=       [to_channel_dimension_format(lowerCamelCase__     ,		lowerCamelCase__				) for image in images]

							__lowerCamelCase									=       {'pixel_values': images}
							return BatchFeature(data=lowerCamelCase__     ,		tensor_type=lowerCamelCase__				)






			def  lowercase_       ( self     ,		lowerCamelCase__     ,		lowerCamelCase__ = None				)       -> Optional[Any]:



							'''simple docstring'''
							__lowerCamelCase									=       outputs.logits

							# Resize logits and compute semantic segmentation maps
							if target_sizes is not None:
											if len(lowerCamelCase__				) != len(lowerCamelCase__				):
															raise ValueError(
															    'Make sure that you pass in as many target sizes as the batch dimension of the logits'				)

											if is_torch_tensor(lowerCamelCase__				):
															__lowerCamelCase									=       target_sizes.numpy()

											__lowerCamelCase									=       []

											for idx in range(len(lowerCamelCase__				)				):
															__lowerCamelCase									=       torch.nn.functional.interpolate(
															    logits[idx].unsqueeze(dim=0				)     ,		size=target_sizes[idx]     ,		mode='bilinear'     ,		align_corners=lowerCamelCase__				)
															__lowerCamelCase									=       resized_logits[0].argmax(dim=0				)
															semantic_segmentation.append(lowerCamelCase__				)
							else:
											__lowerCamelCase									=       logits.argmax(dim=1				)
											__lowerCamelCase									=       [semantic_segmentation[i] for i in range(semantic_segmentation.shape[0]				)]

							return semantic_segmentation


