






import torch

from diffusers import DDIMParallelScheduler

from .test_schedulers import SchedulerCommonTest


class       __SCREAMING_SNAKE_CASE   (				__lowercase):
						_SCREAMING_SNAKE_CASE		:    Dict						=   (DDIMParallelScheduler,)
						_SCREAMING_SNAKE_CASE		:    Dict						=   (('''eta''', 0.0), ('''num_inference_steps''', 50))






						def  UpperCamelCase__ (		self       ,  **_UpperCamelCase				):






												"""simple docstring"""
												lowerCAmelCase__        =  {
												    'num_train_timesteps': 10_00,
												    'beta_start': 0.00_01,
												    'beta_end': 0.02,
												    'beta_schedule': 'linear',
												    'clip_sample': True,
												}

												config.update(**_UpperCamelCase				)
												return config






						def  UpperCamelCase__ (		self       ,  **_UpperCamelCase				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.scheduler_classes[0]
												lowerCAmelCase__        =  self.get_scheduler_config(**_UpperCamelCase				)
												lowerCAmelCase__        =  scheduler_class(**_UpperCamelCase				)

												lowerCAmelCase__  ,    lowerCAmelCase__        =  10, 0.0

												lowerCAmelCase__        =  self.dummy_model()
												lowerCAmelCase__        =  self.dummy_sample_deter

												scheduler.set_timesteps(_UpperCamelCase				)

												for t in scheduler.timesteps:
																		lowerCAmelCase__        =  model(_UpperCamelCase       ,  _UpperCamelCase				)
																		lowerCAmelCase__        =  scheduler.step(_UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase				).prev_sample

												return sample






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												for timesteps in [1_00, 5_00, 10_00]:
																		self.check_over_configs(num_train_timesteps=_UpperCamelCase				)






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												for steps_offset in [0, 1]:
																		self.check_over_configs(steps_offset=_UpperCamelCase				)

												lowerCAmelCase__        =  self.scheduler_classes[0]
												lowerCAmelCase__        =  self.get_scheduler_config(steps_offset=1				)
												lowerCAmelCase__        =  scheduler_class(**_UpperCamelCase				)
												scheduler.set_timesteps(5				)
												assert torch.equal(scheduler.timesteps       ,  torch.LongTensor([8_01, 6_01, 4_01, 2_01, 1]				)				)






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												for beta_start, beta_end in zip([0.00_01, 0.0_01, 0.01, 0.1]       ,  [0.0_02, 0.02, 0.2, 2]				):
																		self.check_over_configs(beta_start=_UpperCamelCase       ,  beta_end=_UpperCamelCase				)






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												for schedule in ["linear", "squaredcos_cap_v2"]:
																		self.check_over_configs(beta_schedule=_UpperCamelCase				)






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												for prediction_type in ["epsilon", "v_prediction"]:
																		self.check_over_configs(prediction_type=_UpperCamelCase				)






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												for clip_sample in [True, False]:
																		self.check_over_configs(clip_sample=_UpperCamelCase				)






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												for timestep_spacing in ["trailing", "leading"]:
																		self.check_over_configs(timestep_spacing=_UpperCamelCase				)






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												for rescale_betas_zero_snr in [True, False]:
																		self.check_over_configs(rescale_betas_zero_snr=_UpperCamelCase				)






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												self.check_over_configs(thresholding=_UpperCamelCase				)
												for threshold in [0.5, 1.0, 2.0]:
																		for prediction_type in ["epsilon", "v_prediction"]:
																								self.check_over_configs(
																								    thresholding=_UpperCamelCase       ,  prediction_type=_UpperCamelCase       ,  sample_max_value=_UpperCamelCase       ,  )






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												for t in [1, 10, 49]:
																		self.check_over_forward(time_step=_UpperCamelCase				)






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												for t, num_inference_steps in zip([1, 10, 50]       ,  [10, 50, 5_00]				):
																		self.check_over_forward(time_step=_UpperCamelCase       ,  num_inference_steps=_UpperCamelCase				)






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												for t, eta in zip([1, 10, 49]       ,  [0.0, 0.5, 1.0]				):
																		self.check_over_forward(time_step=_UpperCamelCase       ,  eta=_UpperCamelCase				)






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.scheduler_classes[0]
												lowerCAmelCase__        =  self.get_scheduler_config()
												lowerCAmelCase__        =  scheduler_class(**_UpperCamelCase				)

												assert torch.sum(torch.abs(scheduler._get_variance(0       ,  0				) - 0.0				)				) < 1E-5
												assert torch.sum(torch.abs(scheduler._get_variance(4_20       ,  4_00				) - 0.1_47_71				)				) < 1E-5
												assert torch.sum(torch.abs(scheduler._get_variance(9_80       ,  9_60				) - 0.3_24_60				)				) < 1E-5
												assert torch.sum(torch.abs(scheduler._get_variance(0       ,  0				) - 0.0				)				) < 1E-5
												assert torch.sum(torch.abs(scheduler._get_variance(4_87       ,  4_86				) - 0.0_09_79				)				) < 1E-5
												assert torch.sum(torch.abs(scheduler._get_variance(9_99       ,  9_98				) - 0.02				)				) < 1E-5






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.scheduler_classes[0]
												lowerCAmelCase__        =  self.get_scheduler_config()
												lowerCAmelCase__        =  scheduler_class(**_UpperCamelCase				)

												lowerCAmelCase__  ,    lowerCAmelCase__        =  10, 0.0
												scheduler.set_timesteps(_UpperCamelCase				)

												lowerCAmelCase__        =  self.dummy_model()
												lowerCAmelCase__        =  self.dummy_sample_deter
												lowerCAmelCase__        =  self.dummy_sample_deter + 0.1
												lowerCAmelCase__        =  self.dummy_sample_deter - 0.1

												lowerCAmelCase__        =  samplea.shape[0]
												lowerCAmelCase__        =  torch.stack([samplea, samplea, samplea]       ,  dim=0				)
												lowerCAmelCase__        =  torch.arange(_UpperCamelCase				)[0:3, None].repeat(1       ,  _UpperCamelCase				)

												lowerCAmelCase__        =  model(samples.flatten(0       ,  1				)       ,  timesteps.flatten(0       ,  1				)				)
												lowerCAmelCase__        =  scheduler.batch_step_no_noise(_UpperCamelCase       ,  timesteps.flatten(0       ,  1				)       ,  samples.flatten(0       ,  1				)       ,  _UpperCamelCase				)

												lowerCAmelCase__        =  torch.sum(torch.abs(_UpperCamelCase				)				)
												lowerCAmelCase__        =  torch.mean(torch.abs(_UpperCamelCase				)				)

												assert abs(result_sum.item() - 11_47.79_04				) < 1E-2
												assert abs(result_mean.item() - 0.49_82				) < 1E-3






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.full_loop()

												lowerCAmelCase__        =  torch.sum(torch.abs(_UpperCamelCase				)				)
												lowerCAmelCase__        =  torch.mean(torch.abs(_UpperCamelCase				)				)

												assert abs(result_sum.item() - 1_72.00_67				) < 1E-2
												assert abs(result_mean.item() - 0.22_39_67				) < 1E-3






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.full_loop(prediction_type='v_prediction'				)

												lowerCAmelCase__        =  torch.sum(torch.abs(_UpperCamelCase				)				)
												lowerCAmelCase__        =  torch.mean(torch.abs(_UpperCamelCase				)				)

												assert abs(result_sum.item() - 52.53_02				) < 1E-2
												assert abs(result_mean.item() - 0.06_84				) < 1E-3






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												# We specify different beta, so that the first alpha is 0.99
												lowerCAmelCase__        =  self.full_loop(set_alpha_to_one=_UpperCamelCase       ,  beta_start=0.01				)
												lowerCAmelCase__        =  torch.sum(torch.abs(_UpperCamelCase				)				)
												lowerCAmelCase__        =  torch.mean(torch.abs(_UpperCamelCase				)				)

												assert abs(result_sum.item() - 1_49.82_95				) < 1E-2
												assert abs(result_mean.item() - 0.19_51				) < 1E-3







						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												# We specify different beta, so that the first alpha is 0.99
												lowerCAmelCase__        =  self.full_loop(set_alpha_to_one=_UpperCamelCase       ,  beta_start=0.01				)
												lowerCAmelCase__        =  torch.sum(torch.abs(_UpperCamelCase				)				)
												lowerCAmelCase__        =  torch.mean(torch.abs(_UpperCamelCase				)				)

												assert abs(result_sum.item() - 1_49.07_84				) < 1E-2
												assert abs(result_mean.item() - 0.19_41				) < 1E-3













import qiskit







def 		_UpperCamelCase				(      UpperCamelCase_    :   int      ,    UpperCamelCase_    :   int						)					->				qiskit.result.counts.Counts:

						"""simple docstring"""



						lowerCAmelCase__        =  qiskit.Aer.get_backend('aer_simulator'						)

						# Create a Quantum Circuit acting on the q register
						lowerCAmelCase__        =  qiskit.QuantumCircuit(UpperCamelCase_      ,    UpperCamelCase_						)

						# Map the quantum measurement to the classical bits
						circuit.measure([0]      ,    [0]						)

						# Execute the circuit on the simulator
						lowerCAmelCase__        =  qiskit.execute(UpperCamelCase_      ,    UpperCamelCase_      ,    shots=1000						)

						# Return the histogram data of the results of the experiment.
						return job.result().get_counts(UpperCamelCase_						)


if __name__ == "__main__":
					print(f'Total count for various states are: {single_qubit_measure(1, 1)}')





