code: 
  
  
  
  
  
  '''simple docstring'''
  
  
  import json
  import os
  import tempfile
  
  from transformers.testing_utils import check_json_file_has_correct_format, require_torch, require_vision
  from transformers.utils import is_torch_available, is_vision_available
  
  
  if is_torch_available():
  				import numpy as np
  				import torch
  
  if is_vision_available():
  				from PIL import Image
  
  
  
  
  def    __a (     UpperCAmelCase       ,			UpperCAmelCase=False       ,			UpperCAmelCase=False       ,			UpperCAmelCase=False    )      ->Optional[Any]:
  
  
  
  	"""simple docstring"""
  
  
  
  
  
  
  
  	assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"
  
  	A							  =      []
  	for i in range(image_processor_tester.batch_size    ):
  		if equal_resolution:
  			A							  =      A							  =      image_processor_tester.max_resolution
  		else:
  			# To avoid getting image width/height 0
  			A							  =      image_processor_tester.min_resolution
  			if getattr(__snake_case       ,			"""size_divisor"""       ,			__snake_case    ):
  				# If `size_divisor` is defined, the image needs to have width/size >= `size_divisor`
  				A							  =      max(image_processor_tester.size_divisor       ,			__snake_case    )
  			A  ,    A							  =      np.random.choice(np.arange(__snake_case       ,			image_processor_tester.max_resolution    )       ,			2    )
  		image_inputs.append(
  		    np.random.randint(255       ,			size=(image_processor_tester.num_channels, width, height)       ,			dtype=np.uinta    )    )
  
  	if not numpify and not torchify:
  		# PIL expects the channel dimension as last dimension
  		A							  =      [Image.fromarray(np.moveaxis(__snake_case       ,			0       ,			-1    )    ) for image in image_inputs]
  
  	if torchify:
  		A							  =      [torch.from_numpy(__snake_case    ) for image in image_inputs]
  
  	return image_inputs
  
  
  
  
  def    __a (     UpperCAmelCase       ,			UpperCAmelCase=10       ,			UpperCAmelCase=10       ,			UpperCAmelCase=False       ,			UpperCAmelCase=False    )      ->List[str]:
  
  
  
  	"""simple docstring"""
  
  
  
  
  
  
  
  	A							  =      []
  	for i in range(image_processor_tester.num_frames    ):
  		video.append(np.random.randint(255       ,			size=(image_processor_tester.num_channels, width, height)       ,			dtype=np.uinta    )    )
  
  	if not numpify and not torchify:
  		# PIL expects the channel dimension as last dimension
  		A							  =      [Image.fromarray(np.moveaxis(__snake_case       ,			0       ,			-1    )    ) for frame in video]
  
  	if torchify:
  		A							  =      [torch.from_numpy(__snake_case    ) for frame in video]
  
  	return video
  
  
  
  
  def    __a (     UpperCAmelCase       ,			UpperCAmelCase=False       ,			UpperCAmelCase=False       ,			UpperCAmelCase=False    )      ->Tuple:
  
  
  
  	"""simple docstring"""
  
  
  
  
  
  
  
  	assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"
  
  	A							  =      []
  	for i in range(image_processor_tester.batch_size    ):
  		if equal_resolution:
  			A							  =      A							  =      image_processor_tester.max_resolution
  		else:
  			A  ,    A							  =      np.random.choice(
  			    np.arange(image_processor_tester.min_resolution       ,			image_processor_tester.max_resolution    )       ,			2    )
  			A							  =      prepare_video(
  			    image_processor_tester=__snake_case       ,			width=__snake_case       ,			height=__snake_case       ,			numpify=__snake_case       ,			torchify=__snake_case       ,			)
  		video_inputs.append(__snake_case    )
  
  	return video_inputs
  
  
  
  class 							__UpperCAmelCase  :
  
  
  
  
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		__lowerCAmelCase 				=    None
  
  
  
  
  
  
  
  		def        A	(self						:      str      ):
  			A							  =      self.image_processing_class(**self.image_processor_dict      )
  			A							  =      json.loads(image_processor.to_json_string()      )
  			for key, value in self.image_processor_dict.items():
  				self.assertEqual(obj[key]      ,      _lowerCAmelCase      )
  
  
  
  
  
  
  
  		def        A	(self						:      Any      ):
  			A							  =      self.image_processing_class(**self.image_processor_dict      )
  
  			with tempfile.TemporaryDirectory() as tmpdirname:
  				A							  =      os.path.join(_lowerCAmelCase      ,      """image_processor.json"""      )
  				image_processor_first.to_json_file(_lowerCAmelCase      )
  				A							  =      self.image_processing_class.from_json_file(_lowerCAmelCase      )
  
  			self.assertEqual(image_processor_second.to_dict()      ,      image_processor_first.to_dict()      )
  
  
  
  
  
  
  
  		def        A	(self						:      Optional[int]      ):
  			A							  =      self.image_processing_class(**self.image_processor_dict      )
  
  			with tempfile.TemporaryDirectory() as tmpdirname:
  				A							  =      image_processor_first.save_pretrained(_lowerCAmelCase      )[0]
  				check_json_file_has_correct_format(_lowerCAmelCase      )
  				A							  =      self.image_processing_class.from_pretrained(_lowerCAmelCase      )
  
  			self.assertEqual(image_processor_second.to_dict()      ,      image_processor_first.to_dict()      )
  
  
  
  
  
  
  
  		def        A	(self						:      Union[str, Any]      ):
  			A							  =      self.image_processing_class()
  			self.assertIsNotNone(_lowerCAmelCase      )
  
  
  
  
  
  
  
  		@require_torch
  		@require_vision
  		def        A	(self						:      Any      ):
  
  
  
  
  
  
  
  			if self.test_cast_dtype is not None:
  				# Initialize image_processor
  				A							  =      self.image_processing_class(**self.image_processor_dict      )
  
  				# create random PyTorch tensors
  				A							  =      prepare_image_inputs(self.image_processor_tester      ,      equal_resolution=_lowerCAmelCase      ,      torchify=_lowerCAmelCase      )
  
  				A							  =      image_processor(_lowerCAmelCase      ,      return_tensors="""pt"""      )
  				# for layoutLM compatiblity
  				self.assertEqual(encoding.pixel_values.device      ,      torch.device("""cpu"""      )      )
  				self.assertEqual(encoding.pixel_values.dtype      ,      torch.floataa      )
  
  				A							  =      image_processor(_lowerCAmelCase      ,      return_tensors="""pt"""      ).to(torch.floataa      )
  				self.assertEqual(encoding.pixel_values.device      ,      torch.device("""cpu"""      )      )
  				self.assertEqual(encoding.pixel_values.dtype      ,      torch.floataa      )
  
  				A							  =      image_processor(_lowerCAmelCase      ,      return_tensors="""pt"""      ).to("""cpu"""      ,      torch.bfloataa      )
  				self.assertEqual(encoding.pixel_values.device      ,      torch.device("""cpu"""      )      )
  				self.assertEqual(encoding.pixel_values.dtype      ,      torch.bfloataa      )
  
  				with self.assertRaises(_lowerCAmelCase      ):
  					A							  =      image_processor(_lowerCAmelCase      ,      return_tensors="""pt"""      ).to(torch.bfloataa      ,      """cpu"""      )
  
  				# Try with text + image feature
  				A							  =      image_processor(_lowerCAmelCase      ,      return_tensors="""pt"""      )
  				encoding.update({"""input_ids""": torch.LongTensor([[1, 2, 3], [4, 5, 6]]      )}      )
  				A							  =      encoding.to(torch.floataa      )
  
  				self.assertEqual(encoding.pixel_values.device      ,      torch.device("""cpu"""      )      )
  				self.assertEqual(encoding.pixel_values.dtype      ,      torch.floataa      )
  				self.assertEqual(encoding.input_ids.dtype      ,      torch.long      )
  
  
style_context: 
  
  
  
  
  
  '''simple docstring'''
  
  
  import torch
  
  from diffusers import KDPMaAncestralDiscreteScheduler
  from diffusers.utils import torch_device
  
  from .test_schedulers import SchedulerCommonTest
  
  
  
  class 							__UpperCAmelCase  (       A__						):
  
  
  
  
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		__lowerCAmelCase 				=    (KDPMaAncestralDiscreteScheduler,)
  		__lowerCAmelCase 				=    10
  
  
  
  
  
  
  
  		def        A     (self						:      Any      ,      **_lowerCAmelCase						:      List[Any]      ):
  			A							  =      {
  			    """num_train_timesteps""": 1100,
  			    """beta_start""": 0.0_001,
  			    """beta_end""": 0.02,
  			    """beta_schedule""": """linear""",
  			}
  
  			config.update(**_lowerCAmelCase      )
  			return config
  
  
  
  
  
  
  
  		def        A     (self						:      Dict      ):
  			for timesteps in [10, 50, 100, 1000]:
  				self.check_over_configs(num_train_timesteps=_lowerCAmelCase      )
  
  
  
  
  
  
  
  		def        A     (self						:      Optional[int]      ):
  			for beta_start, beta_end in zip([0.00_001, 0.0_001, 0.001]      ,      [0.0_002, 0.002, 0.02]      ):
  				self.check_over_configs(beta_start=_lowerCAmelCase      ,      beta_end=_lowerCAmelCase      )
  
  
  
  
  
  
  
  		def        A     (self						:      Tuple      ):
  			for schedule in ["linear", "scaled_linear"]:
  				self.check_over_configs(beta_schedule=_lowerCAmelCase      )
  
  
  
  
  
  
  
  		def        A     (self						:      Dict      ):
  			if torch_device == "mps":
  				return
  			A							  =      self.scheduler_classes[0]
  			A							  =      self.get_scheduler_config()
  			A							  =      scheduler_class(**_lowerCAmelCase      )
  
  			scheduler.set_timesteps(self.num_inference_steps      )
  
  			A							  =      torch.manual_seed(0      )
  
  			A							  =      self.dummy_model()
  			A							  =      self.dummy_sample_deter * scheduler.init_noise_sigma
  			A							  =      sample.to(_lowerCAmelCase      )
  
  			for i, t in enumerate(scheduler.timesteps      ):
  				A							  =      scheduler.scale_model_input(_lowerCAmelCase      ,      _lowerCAmelCase      )
  
  				A							  =      model(_lowerCAmelCase      ,      _lowerCAmelCase      )
  
  				A							  =      scheduler.step(_lowerCAmelCase      ,      _lowerCAmelCase      ,      _lowerCAmelCase      ,      generator=_lowerCAmelCase      )
  				A							  =      output.prev_sample
  
  			A							  =      torch.sum(torch.abs(_lowerCAmelCase      )      )
  			A							  =      torch.mean(torch.abs(_lowerCAmelCase      )      )
  
  			assert abs(result_sum.item() - 13_849.3_877      ) < 1e-2
  			assert abs(result_mean.item() - 18.0_331      ) < 5e-3
  
  
  
  
  
  
  
  		def        A     (self						:      Union[str, Any]      ):
  			for prediction_type in ["epsilon", "v_prediction"]:
  				self.check_over_configs(prediction_type=_lowerCAmelCase      )
  
  
  
  
  
  
  
  		def        A     (self						:      Dict      ):
  			if torch_device == "mps":
  				return
  			A							  =      self.scheduler_classes[0]
  			A							  =      self.get_scheduler_config(prediction_type="""v_prediction"""      )
  			A							  =      scheduler_class(**_lowerCAmelCase      )
  
  			scheduler.set_timesteps(self.num_inference_steps      )
  
  			A							  =      self.dummy_model()
  			A							  =      self.dummy_sample_deter * scheduler.init_noise_sigma
  			A							  =      sample.to(_lowerCAmelCase      )
  
  			A							  =      torch.manual_seed(0      )
  
  			for i, t in enumerate(scheduler.timesteps      ):
  				A							  =      scheduler.scale_model_input(_lowerCAmelCase      ,      _lowerCAmelCase      )
  
  				A							  =      model(_lowerCAmelCase      ,      _lowerCAmelCase      )
  
  				A							  =      scheduler.step(_lowerCAmelCase      ,      _lowerCAmelCase      ,      _lowerCAmelCase      ,      generator=_lowerCAmelCase      )
  				A							  =      output.prev_sample
  
  			A							  =      torch.sum(torch.abs(_lowerCAmelCase      )      )
  			A							  =      torch.mean(torch.abs(_lowerCAmelCase      )      )
  
  			assert abs(result_sum.item() - 328.9_970      ) < 1e-2
  			assert abs(result_mean.item() - 0.4_284      ) < 1e-3
  
  
  
  
  
  
  
  		def        A     (self						:      Optional[int]      ):
  			if torch_device == "mps":
  				return
  			A							  =      self.scheduler_classes[0]
  			A							  =      self.get_scheduler_config()
  			A							  =      scheduler_class(**_lowerCAmelCase      )
  
  			scheduler.set_timesteps(self.num_inference_steps      ,      device=_lowerCAmelCase      )
  			A							  =      torch.manual_seed(0      )
  
  			A							  =      self.dummy_model()
  			A							  =      self.dummy_sample_deter.to(_lowerCAmelCase      ) * scheduler.init_noise_sigma
  
  			for t in scheduler.timesteps:
  				A							  =      scheduler.scale_model_input(_lowerCAmelCase      ,      _lowerCAmelCase      )
  
  				A							  =      model(_lowerCAmelCase      ,      _lowerCAmelCase      )
  
  				A							  =      scheduler.step(_lowerCAmelCase      ,      _lowerCAmelCase      ,      _lowerCAmelCase      ,      generator=_lowerCAmelCase      )
  				A							  =      output.prev_sample
  
  			A							  =      torch.sum(torch.abs(_lowerCAmelCase      )      )
  			A							  =      torch.mean(torch.abs(_lowerCAmelCase      )      )
  
  			assert abs(result_sum.item() - 13_849.3_818      ) < 1e-1
  			assert abs(result_mean.item() - 18.0_331      ) < 1e-3
  
  