






"""simple docstring"""



import json
import os
from dataclasses import dataclass

import numpy as np
import pyarrow as pa

import datasets
from utils import get_duration


_UpperCamelCase						:    int		=						1_0_0_0_0_0_0_0_0_0_0_0
_UpperCamelCase						:    Union[str, Any]		=						1_0_0_0_0

_UpperCamelCase,						_UpperCamelCase						:    Tuple		=						os.path.split(__file__)
_UpperCamelCase						:    List[Any]		=						os.path.join(RESULTS_BASEPATH, 'results', RESULTS_FILENAME.replace('.py', '.json'))
def 		_SCREAMING_SNAKE_CASE					(       __snake_case     :    int						,   __snake_case     :    int       ):





  '''simple docstring'''





  lowercase				       =			pa.Table.from_pydict({'col': [0] * chunk_size}       )
  lowercase				       =			pa.concat_tables([table] * (num_examples // chunk_size)       )
  return datasets.Dataset(__snake_case						,   fingerprint='table_100B'       )

@dataclass
class 			a	:
    UpperCAmelCase_					:	int
    UpperCAmelCase_					:	int
    UpperCAmelCase_					:	int
    UpperCAmelCase_					:	int







    def      UpperCamelCase_ (     self			):
      lowercase				       =			np.random.default_rng(self.seed			)
      lowercase				       =			rng.integers(low=self.low				,						high=self.high				,						size=self.size			).tolist()







    def __iter__(     self			):
      return iter(self._sampled_values			)







    def __len__(     self			):
      return self.size


@get_duration
def 		_SCREAMING_SNAKE_CASE					(       __snake_case     :    datasets.Dataset       ):





  '''simple docstring'''





  lowercase				       =			dataset[0]
@get_duration
def 		_SCREAMING_SNAKE_CASE					(       __snake_case     :    datasets.Dataset       ):





  '''simple docstring'''





  lowercase				       =			dataset[-1]
@get_duration
def 		_SCREAMING_SNAKE_CASE					(       __snake_case     :    datasets.Dataset       ):





  '''simple docstring'''





  lowercase				       =			dataset[range(len(__snake_case       ) // 2						,   len(__snake_case       ) // 2 + 10_24       )]
@get_duration
def 		_SCREAMING_SNAKE_CASE					(       __snake_case     :    datasets.Dataset       ):





  '''simple docstring'''





  lowercase				       =			dataset[RandIter(0						,   len(__snake_case       )						,   10_24						,   seed=42       )]
def 		_SCREAMING_SNAKE_CASE					(       ):





  '''simple docstring'''





  lowercase				       =			{'num examples': SPEED_TEST_N_EXAMPLES}
  lowercase				       =			(get_first_row, get_last_row, get_batch_of_aaaa_rows, get_batch_of_aaaa_random_rows)
  print('generating dataset'       )
  lowercase				       =			generate_100B_dataset(num_examples=__snake_case						,   chunk_size=__snake_case       )
  print('Functions'       )
  for func in functions:
    print(func.__name__       )
    lowercase				       =			func(__snake_case       )

  with open(__snake_case						,   'wb'       ) as f:
    f.write(json.dumps(__snake_case       ).encode('utf-8'       )       )


if __name__ == "__main__":  # useful to run the profiler
    benchmark_table_100B()



"""simple docstring"""

import gc
import tempfile
import unittest

import numpy as np
import torch

from diffusers import VersatileDiffusionDualGuidedPipeline
from diffusers.utils.testing_utils import load_image, nightly, require_torch_gpu, torch_device


__lowercase    =				False






@nightly
@require_torch_gpu
class 		_lowercase (						unittest.TestCase      ):



						"""simple docstring"""




						def   UpperCAmelCase_ (				self							:    List[str]				)				->				List[Any]:
													'''simple docstring'''



													super().tearDown()
													gc.collect()
													torch.cuda.empty_cache()





						def   UpperCAmelCase_ (				self							:    List[Any]				)				->				List[Any]:
													'''simple docstring'''



													__UpperCamelCase							=VersatileDiffusionDualGuidedPipeline.from_pretrained('''shi-labs/versatile-diffusion'''				)
													# remove text_unet
													pipe.remove_unused_weights()
													pipe.to(UpperCamelCase__				)
													pipe.set_progress_bar_config(disable=UpperCamelCase__				)

													__UpperCamelCase							=load_image(
													    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg'''				)

													__UpperCamelCase							=torch.manual_seed(0				)
													__UpperCamelCase							=pipe(
													    prompt='''first prompt'''     , image=UpperCamelCase__     , text_to_image_strength=0.75     , generator=UpperCamelCase__     , guidance_scale=7.5     , num_inference_steps=2     , output_type='''numpy'''     , ).images

													with tempfile.TemporaryDirectory() as tmpdirname:
																				pipe.save_pretrained(UpperCamelCase__				)
																				__UpperCamelCase							=VersatileDiffusionDualGuidedPipeline.from_pretrained(UpperCamelCase__				)

													pipe.to(UpperCamelCase__				)
													pipe.set_progress_bar_config(disable=UpperCamelCase__				)

													__UpperCamelCase							=generator.manual_seed(0				)
													__UpperCamelCase							=pipe(
													    prompt='''first prompt'''     , image=UpperCamelCase__     , text_to_image_strength=0.75     , generator=UpperCamelCase__     , guidance_scale=7.5     , num_inference_steps=2     , output_type='''numpy'''     , ).images

													assert np.abs(image - new_image				).sum() < 1E-5, "Models don't have the same forward pass"





						def   UpperCAmelCase_ (				self							:    Optional[int]				)				->				Optional[int]:
													'''simple docstring'''



													__UpperCamelCase							=VersatileDiffusionDualGuidedPipeline.from_pretrained('''shi-labs/versatile-diffusion'''				)
													pipe.remove_unused_weights()
													pipe.to(UpperCamelCase__				)
													pipe.set_progress_bar_config(disable=UpperCamelCase__				)

													__UpperCamelCase							='''cyberpunk 2077'''
													__UpperCamelCase							=load_image(
													    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg'''				)
													__UpperCamelCase							=torch.manual_seed(0				)
													__UpperCamelCase							=pipe(
													    prompt=UpperCamelCase__     , image=UpperCamelCase__     , text_to_image_strength=0.75     , generator=UpperCamelCase__     , guidance_scale=7.5     , num_inference_steps=50     , output_type='''numpy'''     , ).images

													__UpperCamelCase							=image[0, 253:256, 253:256, -1]

													assert image.shape == (1, 512, 512, 3)
													__UpperCamelCase							=np.array([0.07_87, 0.08_49, 0.08_26, 0.08_12, 0.08_07, 0.07_95, 0.08_18, 0.07_98, 0.07_79]				)

													assert np.abs(image_slice.flatten() - expected_slice				).max() < 1E-2



