"""simple docstring"""






import inspect
import os
import unittest
from dataclasses import dataclass

import torch

from accelerate import Accelerator, DistributedDataParallelKwargs, GradScalerKwargs
from accelerate.state import AcceleratorState
from accelerate.test_utils import execute_subprocess_async, require_cuda, require_multi_gpu
from accelerate.utils import KwargsHandler
@dataclass
class        snake_case (				__UpperCAmelCase       ):




					"""simple docstring"""

					snake_case__       					=				0
					snake_case__       					=				False
					snake_case__       					=				3.0






class        snake_case (				unittest.TestCase       ):




					"""simple docstring"""

					def 	__lowerCAmelCase		(       self     :			str    ):
									# If no defaults are changed, `to_kwargs` returns an empty dict.
									self.assertDictEqual(MockClass().to_kwargs()					,{}    )
									self.assertDictEqual(MockClass(a=2    ).to_kwargs()					,{'a': 2}    )
									self.assertDictEqual(MockClass(a=2					,b=lowerCamelCase__    ).to_kwargs()					,{'a': 2, 'b': True}    )
									self.assertDictEqual(MockClass(a=2					,c=2.2_5    ).to_kwargs()					,{'a': 2, 'c': 2.2_5}    )







					@require_cuda
					def 	__lowerCAmelCase		(       self     :			str    ):
									# If no defaults are changed, `to_kwargs` returns an empty dict.
									UpperCAmelCase__    =							GradScalerKwargs(init_scale=1_024					,growth_factor=2    )
									AcceleratorState._reset_state()
									UpperCAmelCase__    =							Accelerator(mixed_precision='fp16'					,kwargs_handlers=[scaler_handler]    )
									print(accelerator.use_fpaa    )
									UpperCAmelCase__    =							accelerator.scaler

									# Check the kwargs have been applied
									self.assertEqual(scaler._init_scale					,1_0_2_4.0    )
									self.assertEqual(scaler._growth_factor					,2.0    )

									# Check the other values are at the default
									self.assertEqual(scaler._backoff_factor					,0.5    )
									self.assertEqual(scaler._growth_interval					,2_000    )
									self.assertEqual(scaler._enabled					,lowerCamelCase__    )







					@require_multi_gpu
					def 	__lowerCAmelCase		(       self     :			List[str]    ):
									UpperCAmelCase__    =							['torchrun', f'''--nproc_per_node={torch.cuda.device_count()}''', inspect.getfile(self.__class__    )]
									execute_subprocess_async(lowerCamelCase__					,env=os.environ.copy()    )


if __name__ == "__main__":
						lowerCAmelCase__						:						Tuple		  =			DistributedDataParallelKwargs(bucket_cap_mb=15, find_unused_parameters=True)
						lowerCAmelCase__						:						Any		  =			Accelerator(kwargs_handlers=[ddp_scaler])
						lowerCAmelCase__						:						Union[str, Any]		  =			torch.nn.Linear(100, 200)
						lowerCAmelCase__						:						List[Any]		  =			accelerator.prepare(model)

						# Check the values changed in kwargs
						lowerCAmelCase__						:						List[str]		  =			''
						lowerCAmelCase__						:						Union[str, Any]		  =			model.bucket_bytes_cap // (1_024 * 1_024)
						if observed_bucket_cap_map != 15:
												error_msg += F"Kwargs badly passed, should have `15` but found {observed_bucket_cap_map}.\n"
						if model.find_unused_parameters is not True:
												error_msg += F"Kwargs badly passed, should have `True` but found {model.find_unused_parameters}.\n"

						# Check the values of the defaults
						if model.dim != 0:
												error_msg += F"Default value not respected, should have `0` but found {model.dim}.\n"
						if model.broadcast_buffers is not True:
												error_msg += F"Default value not respected, should have `True` but found {model.broadcast_buffers}.\n"
						if model.gradient_as_bucket_view is not False:
												error_msg += F"Default value not respected, should have `False` but found {model.gradient_as_bucket_view}.\n"

						# Raise error at the end to make sure we don't stop at the first failure.
						if len(error_msg) > 0:
												raise ValueError(error_msg)




"""simple docstring"""






import shutil
import tempfile
import unittest

import numpy as np

from transformers.testing_utils import (
    is_pt_tf_cross_test,
    require_tf,
    require_torch,
    require_torchvision,
    require_vision,
)
from transformers.utils import is_tf_available, is_torch_available, is_vision_available


if is_vision_available():
						from PIL import Image

						from transformers import AutoProcessor, SamImageProcessor, SamProcessor

if is_torch_available():
						import torch

if is_tf_available():
						import tensorflow as tf
@require_vision
@require_torchvision
class        snake_case (				unittest.TestCase       ):




					"""simple docstring"""

					def 	__lowerCAmelCase		(       self     :			Optional[Any]    ):
									UpperCAmelCase__    =							tempfile.mkdtemp()
									UpperCAmelCase__    =							SamImageProcessor()
									UpperCAmelCase__    =							SamProcessor(lowerCamelCase__    )
									processor.save_pretrained(self.tmpdirname    )







					def 	__lowerCAmelCase		(       self     :			str					,**lowerCamelCase__     :			Dict    ):
									return AutoProcessor.from_pretrained(self.tmpdirname					,**lowerCamelCase__    ).image_processor







					def 	__lowerCAmelCase		(       self     :			Optional[int]    ):
									shutil.rmtree(self.tmpdirname    )







					def 	__lowerCAmelCase		(       self     :			Dict    ):
									UpperCAmelCase__    =							[np.random.randint(255					,size=(3, 30, 400)					,dtype=np.uinta    )]

									UpperCAmelCase__    =							[Image.fromarray(np.moveaxis(lowerCamelCase__					,0					,-1    )    ) for x in image_inputs]

									return image_inputs







					def 	__lowerCAmelCase		(       self     :			Optional[Any]    ):
									UpperCAmelCase__    =							SamProcessor(image_processor=self.get_image_processor()    )
									processor.save_pretrained(self.tmpdirname    )

									UpperCAmelCase__    =							self.get_image_processor(do_normalize=lowerCamelCase__					,padding_value=1.0    )

									UpperCAmelCase__    =							SamProcessor.from_pretrained(self.tmpdirname					,do_normalize=lowerCamelCase__					,padding_value=1.0    )

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







					def 	__lowerCAmelCase		(       self     :			Optional[int]    ):
									UpperCAmelCase__    =							self.get_image_processor()

									UpperCAmelCase__    =							SamProcessor(image_processor=lowerCamelCase__    )

									UpperCAmelCase__    =							self.prepare_image_inputs()

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

									input_feat_extract.pop('original_sizes'    )  # pop original_sizes as it is popped in the processor
									input_feat_extract.pop('reshaped_input_sizes'    )  # pop original_sizes as it is popped in the processor

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







					@require_torch
					def 	__lowerCAmelCase		(       self     :			Dict    ):
									UpperCAmelCase__    =							self.get_image_processor()

									UpperCAmelCase__    =							SamProcessor(image_processor=lowerCamelCase__    )
									UpperCAmelCase__    =							[torch.ones((1, 3, 5, 5)    )]

									UpperCAmelCase__    =							[[1_764, 2_646]]

									UpperCAmelCase__    =							[[683, 1_024]]
									UpperCAmelCase__    =							processor.post_process_masks(lowerCamelCase__					,lowerCamelCase__					,lowerCamelCase__    )
									self.assertEqual(masks[0].shape					,(1, 3, 1_764, 2_646)    )

									UpperCAmelCase__    =							processor.post_process_masks(
									    lowerCamelCase__					,torch.tensor(lowerCamelCase__    )					,torch.tensor(lowerCamelCase__    )    )
									self.assertEqual(masks[0].shape					,(1, 3, 1_764, 2_646)    )

									# should also work with np
									UpperCAmelCase__    =							[np.ones((1, 3, 5, 5)    )]
									UpperCAmelCase__    =							processor.post_process_masks(lowerCamelCase__					,np.array(lowerCamelCase__    )					,np.array(lowerCamelCase__    )    )

									self.assertEqual(masks[0].shape					,(1, 3, 1_764, 2_646)    )

									UpperCAmelCase__    =							[[1, 0], [0, 1]]
									with self.assertRaises(lowerCamelCase__    ):
													UpperCAmelCase__    =							processor.post_process_masks(lowerCamelCase__					,np.array(lowerCamelCase__    )					,np.array(lowerCamelCase__    )    )






@require_vision
@require_tf
class        snake_case (				unittest.TestCase       ):




					"""simple docstring"""

					def 	__lowerCAmelCase		(       self     :			List[str]    ):
									UpperCAmelCase__    =							tempfile.mkdtemp()
									UpperCAmelCase__    =							SamImageProcessor()
									UpperCAmelCase__    =							SamProcessor(lowerCamelCase__    )
									processor.save_pretrained(self.tmpdirname    )







					def 	__lowerCAmelCase		(       self     :			str					,**lowerCamelCase__     :			Union[str, Any]    ):
									return AutoProcessor.from_pretrained(self.tmpdirname					,**lowerCamelCase__    ).image_processor







					def 	__lowerCAmelCase		(       self     :			List[Any]    ):
									shutil.rmtree(self.tmpdirname    )







					def 	__lowerCAmelCase		(       self     :			Any    ):
									UpperCAmelCase__    =							[np.random.randint(255					,size=(3, 30, 400)					,dtype=np.uinta    )]

									UpperCAmelCase__    =							[Image.fromarray(np.moveaxis(lowerCamelCase__					,0					,-1    )    ) for x in image_inputs]

									return image_inputs







					def 	__lowerCAmelCase		(       self     :			Optional[int]    ):
									UpperCAmelCase__    =							SamProcessor(image_processor=self.get_image_processor()    )
									processor.save_pretrained(self.tmpdirname    )

									UpperCAmelCase__    =							self.get_image_processor(do_normalize=lowerCamelCase__					,padding_value=1.0    )

									UpperCAmelCase__    =							SamProcessor.from_pretrained(self.tmpdirname					,do_normalize=lowerCamelCase__					,padding_value=1.0    )

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







					def 	__lowerCAmelCase		(       self     :			Union[str, Any]    ):
									UpperCAmelCase__    =							self.get_image_processor()

									UpperCAmelCase__    =							SamProcessor(image_processor=lowerCamelCase__    )

									UpperCAmelCase__    =							self.prepare_image_inputs()

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

									input_feat_extract.pop('original_sizes'    )  # pop original_sizes as it is popped in the processor
									input_feat_extract.pop('reshaped_input_sizes'    )  # pop reshaped_input_sizes as it is popped in the processor

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







					@require_tf
					def 	__lowerCAmelCase		(       self     :			Tuple    ):
									UpperCAmelCase__    =							self.get_image_processor()

									UpperCAmelCase__    =							SamProcessor(image_processor=lowerCamelCase__    )
									UpperCAmelCase__    =							[tf.ones((1, 3, 5, 5)    )]

									UpperCAmelCase__    =							[[1_764, 2_646]]

									UpperCAmelCase__    =							[[683, 1_024]]
									UpperCAmelCase__    =							processor.post_process_masks(lowerCamelCase__					,lowerCamelCase__					,lowerCamelCase__					,return_tensors='tf'    )
									self.assertEqual(masks[0].shape					,(1, 3, 1_764, 2_646)    )

									UpperCAmelCase__    =							processor.post_process_masks(
									    lowerCamelCase__					,tf.convert_to_tensor(lowerCamelCase__    )					,tf.convert_to_tensor(lowerCamelCase__    )					,return_tensors='tf'					,)
									self.assertEqual(masks[0].shape					,(1, 3, 1_764, 2_646)    )

									# should also work with np
									UpperCAmelCase__    =							[np.ones((1, 3, 5, 5)    )]
									UpperCAmelCase__    =							processor.post_process_masks(
									    lowerCamelCase__					,np.array(lowerCamelCase__    )					,np.array(lowerCamelCase__    )					,return_tensors='tf'    )

									self.assertEqual(masks[0].shape					,(1, 3, 1_764, 2_646)    )

									UpperCAmelCase__    =							[[1, 0], [0, 1]]
									with self.assertRaises(tf.errors.InvalidArgumentError    ):
													UpperCAmelCase__    =							processor.post_process_masks(
													    lowerCamelCase__					,np.array(lowerCamelCase__    )					,np.array(lowerCamelCase__    )					,return_tensors='tf'    )






@require_vision
@require_torchvision
class        snake_case (				unittest.TestCase       ):




					"""simple docstring"""

					def 	__lowerCAmelCase		(       self     :			Any    ):
									UpperCAmelCase__    =							tempfile.mkdtemp()
									UpperCAmelCase__    =							SamImageProcessor()
									UpperCAmelCase__    =							SamProcessor(lowerCamelCase__    )
									processor.save_pretrained(self.tmpdirname    )







					def 	__lowerCAmelCase		(       self     :			Dict					,**lowerCamelCase__     :			Any    ):
									return AutoProcessor.from_pretrained(self.tmpdirname					,**lowerCamelCase__    ).image_processor







					def 	__lowerCAmelCase		(       self     :			Optional[Any]    ):
									shutil.rmtree(self.tmpdirname    )







					def 	__lowerCAmelCase		(       self     :			List[str]    ):
									UpperCAmelCase__    =							[np.random.randint(255					,size=(3, 30, 400)					,dtype=np.uinta    )]

									UpperCAmelCase__    =							[Image.fromarray(np.moveaxis(lowerCamelCase__					,0					,-1    )    ) for x in image_inputs]

									return image_inputs







					@is_pt_tf_cross_test
					def 	__lowerCAmelCase		(       self     :			List[Any]    ):
									UpperCAmelCase__    =							self.get_image_processor()

									UpperCAmelCase__    =							SamProcessor(image_processor=lowerCamelCase__    )
									UpperCAmelCase__    =							np.random.randint(0					,2					,size=(1, 3, 5, 5)    ).astype(np.floataa    )
									UpperCAmelCase__    =							[tf.convert_to_tensor(lowerCamelCase__    )]
									UpperCAmelCase__    =							[torch.tensor(lowerCamelCase__    )]

									UpperCAmelCase__    =							[[1_764, 2_646]]

									UpperCAmelCase__    =							[[683, 1_024]]
									UpperCAmelCase__    =							processor.post_process_masks(
									    lowerCamelCase__					,lowerCamelCase__					,lowerCamelCase__					,return_tensors='tf'    )
									UpperCAmelCase__    =							processor.post_process_masks(
									    lowerCamelCase__					,lowerCamelCase__					,lowerCamelCase__					,return_tensors='pt'    )

									self.assertTrue(np.all(tf_masks[0].numpy() == pt_masks[0].numpy()    )    )







					@is_pt_tf_cross_test
					def 	__lowerCAmelCase		(       self     :			Optional[Any]    ):
									UpperCAmelCase__    =							self.get_image_processor()

									UpperCAmelCase__    =							SamProcessor(image_processor=lowerCamelCase__    )

									UpperCAmelCase__    =							self.prepare_image_inputs()

									UpperCAmelCase__    =							image_processor(lowerCamelCase__					,return_tensors='pt'    )['pixel_values'].numpy()
									UpperCAmelCase__    =							processor(images=lowerCamelCase__					,return_tensors='pt'    )['pixel_values'].numpy()

									UpperCAmelCase__    =							image_processor(lowerCamelCase__					,return_tensors='tf'    )['pixel_values'].numpy()
									UpperCAmelCase__    =							processor(images=lowerCamelCase__					,return_tensors='tf'    )['pixel_values'].numpy()

									self.assertTrue(np.allclose(lowerCamelCase__					,lowerCamelCase__    )    )
									self.assertTrue(np.allclose(lowerCamelCase__					,lowerCamelCase__    )    )
									self.assertTrue(np.allclose(lowerCamelCase__					,lowerCamelCase__    )    )



