





from dataclasses import dataclass, field
from typing import Optional

from transformers import AutoConfig, AutoImageProcessor, AutoTokenizer, FlaxVisionEncoderDecoderModel, HfArgumentParser
@dataclass
class        SCREAMING_SNAKE_CASE     :
   _UpperCamelCase					:	Any				      = field(
       metadata={'help': 'The output directory where the model will be written.'}    ,			)
   _UpperCamelCase					:	Dict				      = field(
       metadata={
           'help': (
               'The encoder model checkpoint for weights initialization.'
               'Don\'t set if you want to train an encoder model from scratch.'
           )
       }    ,			)
   _UpperCamelCase					:	Tuple				      = field(
       metadata={
           'help': (
               'The decoder model checkpoint for weights initialization.'
               'Don\'t set if you want to train a decoder model from scratch.'
           )
       }    ,			)
   _UpperCamelCase					:	str				      = field(
       default=UpperCAmelCase_    ,			metadata={'help': 'Pretrained encoder config name or path if not the same as encoder_model_name'}   )
   _UpperCamelCase					:	Tuple				      = field(
       default=UpperCAmelCase_    ,			metadata={'help': 'Pretrained decoder config name or path if not the same as decoder_model_name'}   )






def     __UpperCamelCase						()       ->     Any:
  lowercase__			    =						HfArgumentParser((ModelArguments,)	)
  ((lowercase__ )    ,					 )			    =						parser.parse_args_into_dataclasses()

  # Load pretrained model and tokenizer

  # Use explicit specified encoder config
  if model_args.encoder_config_name:
    lowercase__			    =						AutoConfig.from_pretrained(model_args.encoder_config_name	)
  # Use pretrained encoder model's config
  else:
    lowercase__			    =						AutoConfig.from_pretrained(model_args.encoder_model_name_or_path	)

  # Use explicit specified decoder config
  if model_args.decoder_config_name:
    lowercase__			    =						AutoConfig.from_pretrained(model_args.decoder_config_name	)
  # Use pretrained decoder model's config
  else:
    lowercase__			    =						AutoConfig.from_pretrained(model_args.decoder_model_name_or_path	)

  # necessary for `from_encoder_decoder_pretrained` when `decoder_config` is passed
  lowercase__			    =						True
  lowercase__			    =						True

  lowercase__			    =						FlaxVisionEncoderDecoderModel.from_encoder_decoder_pretrained(
      encoder_pretrained_model_name_or_path=model_args.encoder_model_name_or_path	,		decoder_pretrained_model_name_or_path=model_args.decoder_model_name_or_path	,		encoder_config=UpperCamelCase__	,		decoder_config=UpperCamelCase__	,		)

  # GPT2 only has bos/eos tokens but not decoder_start/pad tokens
  lowercase__			    =						decoder_config.decoder_start_token_id
  lowercase__			    =						decoder_config.pad_token_id
  if decoder_start_token_id is None:
    lowercase__			    =						decoder_config.bos_token_id
  if pad_token_id is None:
    lowercase__			    =						decoder_config.eos_token_id

  # This is necessary to make Flax's generate() work
  lowercase__			    =						decoder_config.eos_token_id
  lowercase__			    =						decoder_start_token_id
  lowercase__			    =						pad_token_id

  lowercase__			    =						AutoImageProcessor.from_pretrained(model_args.encoder_model_name_or_path	)

  lowercase__			    =						AutoTokenizer.from_pretrained(model_args.decoder_model_name_or_path	)
  lowercase__			    =						tokenizer.convert_ids_to_tokens(model.config.pad_token_id	)

  model.save_pretrained(model_args.output_dir	)
  image_processor.save_pretrained(model_args.output_dir	)
  tokenizer.save_pretrained(model_args.output_dir	)


if __name__ == "__main__":
 main()









import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionSAGPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()
class        SCREAMING_SNAKE_CASE     (UpperCAmelCase    ,			UpperCAmelCase    ,			unittest.TestCase   ):
   _UpperCamelCase					:	List[Any]				      = StableDiffusionSAGPipeline
   _UpperCamelCase					:	str				      = TEXT_TO_IMAGE_PARAMS
   _UpperCamelCase					:	Dict				      = TEXT_TO_IMAGE_BATCH_PARAMS
   _UpperCamelCase					:	str				      = TEXT_TO_IMAGE_IMAGE_PARAMS
   _UpperCamelCase					:	Optional[int]				      = TEXT_TO_IMAGE_IMAGE_PARAMS
   _UpperCamelCase					:	Union[str, Any]				      = False


   def  SCREAMING_SNAKE_CASE_							(					self    :       List[str] )->     Dict:





     """simple docstring"""







     torch.manual_seed(0 )
     lowercase__			    =						UNetaDConditionModel(
         block_out_channels=(32, 64)    ,  layers_per_block=2    ,  sample_size=32    ,  in_channels=4    ,  out_channels=4    ,  down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')    ,  up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')    ,  cross_attention_dim=32    ,  )
     lowercase__			    =						DDIMScheduler(
         beta_start=0.00085    ,  beta_end=0.012    ,  beta_schedule='scaled_linear'    ,  clip_sample=a    ,  set_alpha_to_one=a    ,  )
     torch.manual_seed(0 )
     lowercase__			    =						AutoencoderKL(
         block_out_channels=[32, 64]    ,  in_channels=3    ,  out_channels=3    ,  down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']    ,  up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']    ,  latent_channels=4    ,  )
     torch.manual_seed(0 )
     lowercase__			    =						CLIPTextConfig(
         bos_token_id=0    ,  eos_token_id=2    ,  hidden_size=32    ,  intermediate_size=37    ,  layer_norm_eps=1E-0_5    ,  num_attention_heads=4    ,  num_hidden_layers=5    ,  pad_token_id=1    ,  vocab_size=1_000    ,  )
     lowercase__			    =						CLIPTextModel(a )
     lowercase__			    =						CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip' )

     lowercase__			    =						{
         'unet': unet,
         'scheduler': scheduler,
         'vae': vae,
         'text_encoder': text_encoder,
         'tokenizer': tokenizer,
         'safety_checker': None,
         'feature_extractor': None,
     }
     return components


   def  SCREAMING_SNAKE_CASE_							(					self    :       Tuple    ,  a    :       Optional[int]    ,  a    :       Any=0 )->     Union[str, Any]:





     """simple docstring"""







     if str(a ).startswith('mps' ):
       lowercase__			    =						torch.manual_seed(a )
     else:
       lowercase__			    =						torch.Generator(device=a ).manual_seed(a )
     lowercase__			    =						{
         'prompt': '.',
         'generator': generator,
         'num_inference_steps': 2,
         'guidance_scale': 1.0,
         'sag_scale': 1.0,
         'output_type': 'numpy',
     }
     return inputs


   def  SCREAMING_SNAKE_CASE_							(					self    :       Any )->     Any:





     """simple docstring"""







     super().test_inference_batch_single_identical(expected_max_diff=3E-3 )






@slow
@require_torch_gpu
class        SCREAMING_SNAKE_CASE     (unittest.TestCase   ):


   def  SCREAMING_SNAKE_CASE_							(					self    :       str )->     int:





     """simple docstring"""







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


   def  SCREAMING_SNAKE_CASE_							(					self    :       Tuple )->     Optional[Any]:





     """simple docstring"""







     lowercase__			    =						StableDiffusionSAGPipeline.from_pretrained('CompVis/stable-diffusion-v1-4' )
     lowercase__			    =						sag_pipe.to(a )
     sag_pipe.set_progress_bar_config(disable=a )

     lowercase__			    =						'.'
     lowercase__			    =						torch.manual_seed(0 )
     lowercase__			    =						sag_pipe(
         [prompt]    ,  generator=a    ,  guidance_scale=7.5    ,  sag_scale=1.0    ,  num_inference_steps=20    ,  output_type='np' )

     lowercase__			    =						output.images

     lowercase__			    =						image[0, -3:, -3:, -1]

     assert image.shape == (1, 512, 512, 3)
     lowercase__			    =						np.array([0.1568, 0.1738, 0.1695, 0.1693, 0.1507, 0.1705, 0.1547, 0.1751, 0.1949] )

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


   def  SCREAMING_SNAKE_CASE_							(					self    :       Tuple )->     Optional[Any]:





     """simple docstring"""







     lowercase__			    =						StableDiffusionSAGPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base' )
     lowercase__			    =						sag_pipe.to(a )
     sag_pipe.set_progress_bar_config(disable=a )

     lowercase__			    =						'.'
     lowercase__			    =						torch.manual_seed(0 )
     lowercase__			    =						sag_pipe(
         [prompt]    ,  generator=a    ,  guidance_scale=7.5    ,  sag_scale=1.0    ,  num_inference_steps=20    ,  output_type='np' )

     lowercase__			    =						output.images

     lowercase__			    =						image[0, -3:, -3:, -1]

     assert image.shape == (1, 512, 512, 3)
     lowercase__			    =						np.array([0.3459, 0.2876, 0.2537, 0.3002, 0.2671, 0.2160, 0.3026, 0.2262, 0.2371] )

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


   def  SCREAMING_SNAKE_CASE_							(					self    :       Optional[int] )->     List[Any]:





     """simple docstring"""







     lowercase__			    =						StableDiffusionSAGPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base' )
     lowercase__			    =						sag_pipe.to(a )
     sag_pipe.set_progress_bar_config(disable=a )

     lowercase__			    =						'.'
     lowercase__			    =						torch.manual_seed(0 )
     lowercase__			    =						sag_pipe(
         [prompt]    ,  width=768    ,  height=512    ,  generator=a    ,  guidance_scale=7.5    ,  sag_scale=1.0    ,  num_inference_steps=20    ,  output_type='np'    ,  )

     lowercase__			    =						output.images

     assert image.shape == (1, 512, 768, 3)


