


import numpy as np

from transformers import BatchFeature
from transformers.testing_utils import require_tf, require_torch

from .test_feature_extraction_common import FeatureExtractionSavingTestMixin


class 					lowerCAmelCase_ (       _a):
      # to overwrite at feature extractactor specific tests
      lowerCamelCase_         =     None
      lowerCamelCase_         =     None




      @property
      def  _snake_case					(	self						:   List[str]						)      ->Dict:






         """simple docstring"""






         return self.feat_extract_tester.prepare_feat_extract_dict()




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






         """simple docstring"""






         a__ :str						  =    self.feature_extraction_class(**self.feat_extract_dict						)
         self.assertTrue(hasattr(__A   ,     "feature_size"						)						)
         self.assertTrue(hasattr(__A   ,     "sampling_rate"						)						)
         self.assertTrue(hasattr(__A   ,     "padding_value"						)						)




      def  _snake_case					(	self						:   List[Any]						)      ->List[Any]:






         """simple docstring"""






         a__ :List[Any]						  =    self.feat_extract_tester.prepare_inputs_for_common()
         a__ :Any						  =    self.feature_extraction_class(**self.feat_extract_dict						)
         a__ :int						  =    feat_extract.model_input_names[0]

         a__ :Optional[Any]						  =    BatchFeature({input_name: speech_inputs}						)

         self.assertTrue(all(len(__A						) == len(__A						) for x, y in zip(__A   ,     processed_features[input_name]						)						)						)

         a__ :List[Any]						  =    self.feat_extract_tester.prepare_inputs_for_common(equal_length=__A						)
         a__ :int						  =    BatchFeature({input_name: speech_inputs}   ,     tensor_type="np"						)

         a__ :int						  =    processed_features[input_name]

         if len(batch_features_input.shape						) < 3:
            a__ :List[Any]						  =    batch_features_input[:, :, None]

         self.assertTrue(
             batch_features_input.shape
             == (self.feat_extract_tester.batch_size, len(speech_inputs[0]						), self.feat_extract_tester.feature_size)						)




      @require_torch
      def  _snake_case					(	self						:   List[Any]						)      ->List[str]:






         """simple docstring"""






         a__ :Optional[int]						  =    self.feat_extract_tester.prepare_inputs_for_common(equal_length=__A						)
         a__ :int						  =    self.feature_extraction_class(**self.feat_extract_dict						)
         a__ :int						  =    feat_extract.model_input_names[0]

         a__ :str						  =    BatchFeature({input_name: speech_inputs}   ,     tensor_type="pt"						)

         a__ :Any						  =    processed_features[input_name]

         if len(batch_features_input.shape						) < 3:
            a__ :Optional[int]						  =    batch_features_input[:, :, None]

         self.assertTrue(
             batch_features_input.shape
             == (self.feat_extract_tester.batch_size, len(speech_inputs[0]						), self.feat_extract_tester.feature_size)						)




      @require_tf
      def  _snake_case					(	self						:   int						)      ->Optional[int]:






         """simple docstring"""






         a__ :Tuple						  =    self.feat_extract_tester.prepare_inputs_for_common(equal_length=__A						)
         a__ :Dict						  =    self.feature_extraction_class(**self.feat_extract_dict						)
         a__ :List[str]						  =    feat_extract.model_input_names[0]

         a__ :Dict						  =    BatchFeature({input_name: speech_inputs}   ,     tensor_type="tf"						)

         a__ :int						  =    processed_features[input_name]

         if len(batch_features_input.shape						) < 3:
            a__ :Optional[Any]						  =    batch_features_input[:, :, None]

         self.assertTrue(
             batch_features_input.shape
             == (self.feat_extract_tester.batch_size, len(speech_inputs[0]						), self.feat_extract_tester.feature_size)						)




      def  _snake_case					(	self						:   int   ,     __A						:   List[Any]=False						)      ->List[Any]:






         """simple docstring"""






         def _inputs_have_equal_length(__A						:   List[Any]						):
            a__ :int						  =    len(input[0]						)
            for input_slice in input[1:]:
               if len(__A						) != length:
                  return False
            return True

         def _inputs_are_equal(__A						:   List[str]   ,     __A						:   str						):
            if len(__A						) != len(__A						):
               return False

            for input_slice_a, input_slice_a in zip(__A   ,     __A						):
               if not np.allclose(np.asarray(__A						)   ,     np.asarray(__A						)   ,     atol=1E-3						):
                  return False
            return True

         a__ :Dict						  =    self.feature_extraction_class(**self.feat_extract_dict						)
         a__ :Any						  =    self.feat_extract_tester.prepare_inputs_for_common(numpify=__A						)
         a__ :List[str]						  =    feat_extract.model_input_names[0]

         a__ :str						  =    BatchFeature({input_name: speech_inputs}						)

         a__ :Optional[Any]						  =    self.feat_extract_tester.seq_length_diff
         a__ :str						  =    self.feat_extract_tester.max_seq_length + pad_diff
         a__ :Optional[int]						  =    self.feat_extract_tester.min_seq_length
         a__ :Tuple						  =    self.feat_extract_tester.batch_size
         a__ :Optional[Any]						  =    self.feat_extract_tester.feature_size

         # test padding for List[int] + numpy
         a__ :int						  =    feat_extract.pad(__A   ,     padding=__A						)
         a__ :Dict						  =    input_a[input_name]

         a__ :Any						  =    feat_extract.pad(__A   ,     padding="longest"						)
         a__ :Optional[Any]						  =    input_a[input_name]

         a__ :Union[str, Any]						  =    feat_extract.pad(__A   ,     padding="max_length"   ,     max_length=len(speech_inputs[-1]						)						)
         a__ :Optional[Any]						  =    input_a[input_name]

         a__ :str						  =    feat_extract.pad(__A   ,     padding="longest"   ,     return_tensors="np"						)
         a__ :Any						  =    input_a[input_name]

         # max_length parameter has to be provided when setting `padding="max_length"`
         with self.assertRaises(__A						):
            feat_extract.pad(__A   ,     padding="max_length"						)[input_name]

         a__ :List[Any]						  =    feat_extract.pad(
             __A   ,     padding="max_length"   ,     max_length=__A   ,     return_tensors="np"						)
         a__ :Optional[Any]						  =    input_a[input_name]

         self.assertFalse(_inputs_have_equal_length(__A						)						)
         self.assertTrue(_inputs_have_equal_length(__A						)						)
         self.assertTrue(_inputs_have_equal_length(__A						)						)
         self.assertTrue(_inputs_are_equal(__A   ,     __A						)						)
         self.assertTrue(len(input_a[0]						) == pad_min_length						)
         self.assertTrue(len(input_a[1]						) == pad_min_length + pad_diff						)
         self.assertTrue(input_a.shape[:2] == (batch_size, len(input_a[0]						))						)
         self.assertTrue(input_a.shape[:2] == (batch_size, pad_max_length)						)

         if feature_size > 1:
            self.assertTrue(input_a.shape[2] == input_a.shape[2] == feature_size						)

         # test padding for `pad_to_multiple_of` for List[int] + numpy
         a__ :Any						  =    feat_extract.pad(__A   ,     pad_to_multiple_of=10						)
         a__ :List[str]						  =    input_a[input_name]

         a__ :Tuple						  =    feat_extract.pad(__A   ,     padding="longest"   ,     pad_to_multiple_of=10						)
         a__ :int						  =    input_a[input_name]

         a__ :Union[str, Any]						  =    feat_extract.pad(
             __A   ,     padding="max_length"   ,     pad_to_multiple_of=10   ,     max_length=__A						)
         a__ :Any						  =    input_a[input_name]

         a__ :Optional[int]						  =    feat_extract.pad(
             __A   ,     padding="max_length"   ,     pad_to_multiple_of=10   ,     max_length=__A   ,     return_tensors="np"   ,     )
         a__ :Any						  =    input_a[input_name]

         self.assertTrue(all(len(__A						) % 10 == 0 for x in input_a						)						)
         self.assertTrue(_inputs_are_equal(__A   ,     __A						)						)

         a__ :Any						  =    pad_max_length if pad_max_length % 10 == 0 else (pad_max_length // 10 + 1) * 10
         self.assertTrue(all(len(__A						) == expected_mult_pad_length for x in input_a						)						)
         self.assertEqual(input_a.shape[:2]   ,     (batch_size, expected_mult_pad_length)						)

         if feature_size > 1:
            self.assertTrue(input_a.shape[2] == feature_size						)

         # Check padding value is correct
         a__ :int						  =    (np.ones(self.feat_extract_tester.feature_size						) * feat_extract.padding_value).sum()
         self.assertTrue(
             abs(np.asarray(input_a[0]						)[pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)						)
             < 1E-3						)
         self.assertTrue(
             abs(
                 np.asarray(input_a[1]						)[pad_min_length + pad_diff :].sum()
                 - padding_vector_sum * (pad_max_length - pad_min_length - pad_diff)						)
             < 1E-3						)
         self.assertTrue(
             abs(
                 np.asarray(input_a[2]						)[pad_min_length + 2 * pad_diff :].sum()
                 - padding_vector_sum * (pad_max_length - pad_min_length - 2 * pad_diff)						)
             < 1E-3						)
         self.assertTrue(
             abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)						) < 1E-3						)
         self.assertTrue(
             abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (expected_mult_pad_length - pad_min_length)						)
             < 1E-3						)




      def  _snake_case					(	self						:   Any   ,     __A						:   str=False						)      ->List[str]:






         """simple docstring"""






         def _inputs_have_equal_length(__A						:   Tuple						):
            a__ :List[str]						  =    len(input[0]						)
            for input_slice in input[1:]:
               if len(__A						) != length:
                  return False
            return True

         def _inputs_are_equal(__A						:   Dict   ,     __A						:   Dict						):
            if len(__A						) != len(__A						):
               return False

            for input_slice_a, input_slice_a in zip(__A   ,     __A						):
               if not np.allclose(np.asarray(__A						)   ,     np.asarray(__A						)   ,     atol=1E-3						):
                  return False
            return True

         a__ :Optional[Any]						  =    self.feature_extraction_class(**self.feat_extract_dict						)
         a__ :str						  =    self.feat_extract_tester.prepare_inputs_for_common(numpify=__A						)
         a__ :Dict						  =    feat_extract.model_input_names[0]

         a__ :Union[str, Any]						  =    BatchFeature({input_name: speech_inputs}						)

         # truncate to smallest
         a__ :Union[str, Any]						  =    feat_extract.pad(
             __A   ,     padding="max_length"   ,     max_length=len(speech_inputs[0]						)   ,     truncation=__A						)
         a__ :Any						  =    input_a[input_name]

         a__ :Optional[Any]						  =    feat_extract.pad(__A   ,     padding="max_length"   ,     max_length=len(speech_inputs[0]						)						)
         a__ :int						  =    input_a[input_name]

         self.assertTrue(_inputs_have_equal_length(__A						)						)
         self.assertFalse(_inputs_have_equal_length(__A						)						)

         # truncate to smallest with np
         a__ :Optional[int]						  =    feat_extract.pad(
             __A   ,     padding="max_length"   ,     max_length=len(speech_inputs[0]						)   ,     return_tensors="np"   ,     truncation=__A   ,     )
         a__ :List[Any]						  =    input_a[input_name]

         a__ :Tuple						  =    feat_extract.pad(
             __A   ,     padding="max_length"   ,     max_length=len(speech_inputs[0]						)   ,     return_tensors="np"						)
         a__ :Dict						  =    input_a[input_name]

         self.assertTrue(_inputs_have_equal_length(__A						)						)
         self.assertTrue(input_a.shape[1] == len(speech_inputs[0]						)						)

         # since truncation forces padding to be smaller than longest input
         # function can't return `np.ndarray`, but has to return list
         self.assertFalse(_inputs_have_equal_length(__A						)						)

         # truncate to middle
         a__ :Any						  =    feat_extract.pad(
             __A   ,     padding="max_length"   ,     max_length=len(speech_inputs[1]						)   ,     truncation=__A   ,     return_tensors="np"   ,     )
         a__ :int						  =    input_a[input_name]

         a__ :Union[str, Any]						  =    feat_extract.pad(
             __A   ,     padding="max_length"   ,     max_length=len(speech_inputs[1]						)   ,     truncation=__A						)
         a__ :Dict						  =    input_a[input_name]

         a__ :List[str]						  =    feat_extract.pad(
             __A   ,     padding="max_length"   ,     max_length=len(speech_inputs[1]						)   ,     return_tensors="np"						)
         a__ :List[Any]						  =    input_a[input_name]

         self.assertTrue(input_a.shape[1] == len(speech_inputs[1]						)						)
         self.assertTrue(_inputs_have_equal_length(__A						)						)
         self.assertTrue(_inputs_have_equal_length(__A						)						)
         self.assertTrue(_inputs_are_equal(__A   ,     __A						)						)

         # since truncation forces padding to be smaller than longest input
         # function can't return `np.ndarray`, but has to return list
         self.assertFalse(_inputs_have_equal_length(__A						)						)
         self.assertTrue(len(input_a[-1]						) == len(speech_inputs[-1]						)						)

         # padding has to be max_length when setting `truncation=True`
         with self.assertRaises(__A						):
            feat_extract.pad(__A   ,     truncation=__A						)[input_name]

         # padding has to be max_length when setting `truncation=True`
         with self.assertRaises(__A						):
            feat_extract.pad(__A   ,     padding="longest"   ,     truncation=__A						)[input_name]

         # padding has to be max_length when setting `truncation=True`
         with self.assertRaises(__A						):
            feat_extract.pad(__A   ,     padding="longest"   ,     truncation=__A						)[input_name]

         # max_length parameter has to be provided when setting `truncation=True` and padding="max_length"
         with self.assertRaises(__A						):
            feat_extract.pad(__A   ,     padding="max_length"   ,     truncation=__A						)[input_name]

         # test truncation for `pad_to_multiple_of` for List[int] + numpy
         a__ :Optional[int]						  =    12
         a__ :Optional[int]						  =    feat_extract.pad(
             __A   ,     padding="max_length"   ,     max_length=len(speech_inputs[0]						)   ,     pad_to_multiple_of=__A   ,     truncation=__A   ,     )
         a__ :Tuple						  =    input_a[input_name]

         a__ :int						  =    feat_extract.pad(
             __A   ,     padding="max_length"   ,     max_length=len(speech_inputs[0]						)   ,     pad_to_multiple_of=__A   ,     )
         a__ :Tuple						  =    input_a[input_name]

         # retrieve expected_length as multiple of pad_to_multiple_of
         a__ :str						  =    len(speech_inputs[0]						)
         if expected_length % pad_to_multiple_of != 0:
            a__ :Optional[Any]						  =    ((len(speech_inputs[0]						) // pad_to_multiple_of) + 1) * pad_to_multiple_of

         self.assertTrue(len(input_a[0]						) == expected_length						)
         self.assertTrue(_inputs_have_equal_length(__A						)						)
         self.assertFalse(_inputs_have_equal_length(__A						)						)




      def  _snake_case					(	self						:   str						)      ->Dict:






         """simple docstring"""






         self._check_padding(numpify=__A						)




      def  _snake_case					(	self						:   Optional[int]						)      ->Dict:






         """simple docstring"""






         self._check_padding(numpify=__A						)




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






         """simple docstring"""






         self._check_truncation(numpify=__A						)




      def  _snake_case					(	self						:   Tuple						)      ->int:






         """simple docstring"""






         self._check_truncation(numpify=__A						)




      @require_torch
      def  _snake_case					(	self						:   Optional[Any]						)      ->Dict:






         """simple docstring"""






         a__ :str						  =    self.feature_extraction_class(**self.feat_extract_dict						)
         a__ :List[str]						  =    self.feat_extract_tester.prepare_inputs_for_common()
         a__ :Union[str, Any]						  =    feat_extract.model_input_names[0]

         a__ :List[Any]						  =    BatchFeature({input_name: speech_inputs}						)

         a__ :int						  =    feat_extract.pad(__A   ,     padding="longest"   ,     return_tensors="np"						)[input_name]
         a__ :List[Any]						  =    feat_extract.pad(__A   ,     padding="longest"   ,     return_tensors="pt"						)[input_name]

         self.assertTrue(abs(input_np.astype(np.floataa						).sum() - input_pt.numpy().astype(np.floataa						).sum()						) < 1E-2						)




      @require_tf
      def  _snake_case					(	self						:   int						)      ->int:






         """simple docstring"""






         a__ :List[Any]						  =    self.feature_extraction_class(**self.feat_extract_dict						)
         a__ :Dict						  =    self.feat_extract_tester.prepare_inputs_for_common()
         a__ :Any						  =    feat_extract.model_input_names[0]

         a__ :int						  =    BatchFeature({input_name: speech_inputs}						)

         a__ :Tuple						  =    feat_extract.pad(__A   ,     padding="longest"   ,     return_tensors="np"						)[input_name]
         a__ :Optional[Any]						  =    feat_extract.pad(__A   ,     padding="longest"   ,     return_tensors="tf"						)[input_name]

         self.assertTrue(abs(input_np.astype(np.floataa						).sum() - input_tf.numpy().astype(np.floataa						).sum()						) < 1E-2						)




      def  _snake_case					(	self						:   Tuple						)      ->List[str]:






         """simple docstring"""






         a__ :Dict						  =    self.feat_extract_dict
         a__ :List[str]						  =    True
         a__ :Optional[Any]						  =    self.feature_extraction_class(**__A						)
         a__ :Optional[Any]						  =    self.feat_extract_tester.prepare_inputs_for_common()
         a__ :Tuple						  =    [len(__A						) for x in speech_inputs]
         a__ :Optional[int]						  =    feat_extract.model_input_names[0]

         a__ :int						  =    BatchFeature({input_name: speech_inputs}						)

         a__ :List[Any]						  =    feat_extract.pad(__A   ,     padding="longest"   ,     return_tensors="np"						)
         self.assertIn("attention_mask"   ,     __A						)
         self.assertListEqual(list(processed.attention_mask.shape						)   ,     list(processed[input_name].shape[:2]						)						)
         self.assertListEqual(processed.attention_mask.sum(-1						).tolist()   ,     __A						)






      def  _snake_case					(	self						:   int						)      ->Tuple:






         """simple docstring"""






         a__ :Dict						  =    self.feat_extract_dict
         a__ :List[str]						  =    True
         a__ :int						  =    self.feature_extraction_class(**__A						)
         a__ :str						  =    self.feat_extract_tester.prepare_inputs_for_common()
         a__ :Dict						  =    [len(__A						) for x in speech_inputs]
         a__ :List[str]						  =    feat_extract.model_input_names[0]

         a__ :str						  =    BatchFeature({input_name: speech_inputs}						)
         a__ :List[Any]						  =    min(__A						)

         a__ :Any						  =    feat_extract.pad(
             __A   ,     padding="max_length"   ,     max_length=__A   ,     truncation=__A   ,     return_tensors="np"						)
         self.assertIn("attention_mask"   ,     __A						)
         self.assertListEqual(
             list(processed_pad.attention_mask.shape						)   ,     [processed_pad[input_name].shape[0], max_length]						)
         self.assertListEqual(
             processed_pad.attention_mask[:, :max_length].sum(-1						).tolist()   ,     [max_length for x in speech_inputs]						)






import argparse

import torch

from diffusers.pipelines.stable_diffusion.convert_from_ckpt import download_from_original_stable_diffusion_ckpt


if __name__ == "__main__":
		snake_case__			 =						argparse.ArgumentParser()

		parser.add_argument(
		    '''--checkpoint_path''', default=None, type=str, required=True, help='''Path to the checkpoint to convert.'''
		)
		# !wget https://raw.githubusercontent.com/CompVis/stable-diffusion/main/configs/stable-diffusion/v1-inference.yaml
		parser.add_argument(
		    '''--original_config_file''',
		    default=None,
		    type=str,
		    help='''The YAML config file corresponding to the original architecture.''',
		)
		parser.add_argument(
		    '''--num_in_channels''',
		    default=None,
		    type=int,
		    help='''The number of input channels. If `None` number of input channels will be automatically inferred.''',
		)
		parser.add_argument(
		    '''--scheduler_type''',
		    default='''pndm''',
		    type=str,
		    help='''Type of scheduler to use. Should be one of [\'pndm\', \'lms\', \'ddim\', \'euler\', \'euler-ancestral\', \'dpm\']''',
		)
		parser.add_argument(
		    '''--pipeline_type''',
		    default=None,
		    type=str,
		    help=(
		        '''The pipeline type. One of \'FrozenOpenCLIPEmbedder\', \'FrozenCLIPEmbedder\', \'PaintByExample\''''
		        '''. If `None` pipeline will be automatically inferred.'''
		    ),
		)
		parser.add_argument(
		    '''--image_size''',
		    default=None,
		    type=int,
		    help=(
		        '''The image size that the model was trained on. Use 512 for Stable Diffusion v1.X and Stable Siffusion v2'''
		        ''' Base. Use 768 for Stable Diffusion v2.'''
		    ),
		)
		parser.add_argument(
		    '''--prediction_type''',
		    default=None,
		    type=str,
		    help=(
		        '''The prediction type that the model was trained on. Use \'epsilon\' for Stable Diffusion v1.X and Stable'''
		        ''' Diffusion v2 Base. Use \'v_prediction\' for Stable Diffusion v2.'''
		    ),
		)
		parser.add_argument(
		    '''--extract_ema''',
		    action='''store_true''',
		    help=(
		        '''Only relevant for checkpoints that have both EMA and non-EMA weights. Whether to extract the EMA weights'''
		        ''' or not. Defaults to `False`. Add `--extract_ema` to extract the EMA weights. EMA weights usually yield'''
		        ''' higher quality images for inference. Non-EMA weights are usually better to continue fine-tuning.'''
		    ),
		)
		parser.add_argument(
		    '''--upcast_attention''',
		    action='''store_true''',
		    help=(
		        '''Whether the attention computation should always be upcasted. This is necessary when running stable'''
		        ''' diffusion 2.1.'''
		    ),
		)
		parser.add_argument(
		    '''--from_safetensors''',
		    action='''store_true''',
		    help='''If `--checkpoint_path` is in `safetensors` format, load checkpoint with safetensors instead of PyTorch.''',
		)
		parser.add_argument(
		    '''--to_safetensors''',
		    action='''store_true''',
		    help='''Whether to store pipeline in safetensors format or not.''',
		)
		parser.add_argument('''--dump_path''', default=None, type=str, required=True, help='''Path to the output model.''')
		parser.add_argument('''--device''', type=str, help='''Device to use (e.g. cpu, cuda:0, cuda:1, etc.)''')
		parser.add_argument(
		    '''--stable_unclip''',
		    type=str,
		    default=None,
		    required=False,
		    help='''Set if this is a stable unCLIP model. One of \'txt2img\' or \'img2img\'.''',
		)
		parser.add_argument(
		    '''--stable_unclip_prior''',
		    type=str,
		    default=None,
		    required=False,
		    help='''Set if this is a stable unCLIP txt2img model. Selects which prior to use. If `--stable_unclip` is set to `txt2img`, the karlo prior (https://huggingface.co/kakaobrain/karlo-v1-alpha/tree/main/prior) is selected by default.''',
		)
		parser.add_argument(
		    '''--clip_stats_path''',
		    type=str,
		    help='''Path to the clip stats file. Only required if the stable unclip model\'s config specifies `model.params.noise_aug_config.params.clip_stats_path`.''',
		    required=False,
		)
		parser.add_argument(
		    '''--controlnet''', action='''store_true''', default=None, help='''Set flag if this is a controlnet checkpoint.'''
		)
		parser.add_argument('''--half''', action='''store_true''', help='''Save weights in half precision.''')
		parser.add_argument(
		    '''--vae_path''',
		    type=str,
		    default=None,
		    required=False,
		    help='''Set to a path, hub id to an already converted vae to not convert it again.''',
		)
		snake_case__			 =						parser.parse_args()

		snake_case__			 =						download_from_original_stable_diffusion_ckpt(
		    checkpoint_path=args.checkpoint_path,
		    original_config_file=args.original_config_file,
		    image_size=args.image_size,
		    prediction_type=args.prediction_type,
		    model_type=args.pipeline_type,
		    extract_ema=args.extract_ema,
		    scheduler_type=args.scheduler_type,
		    num_in_channels=args.num_in_channels,
		    upcast_attention=args.upcast_attention,
		    from_safetensors=args.from_safetensors,
		    device=args.device,
		    stable_unclip=args.stable_unclip,
		    stable_unclip_prior=args.stable_unclip_prior,
		    clip_stats_path=args.clip_stats_path,
		    controlnet=args.controlnet,
		    vae_path=args.vae_path,
		)

		if args.half:
				pipe.to(torch_dtype=torch.floataa)

		if args.controlnet:
				# only save the controlnet model
				pipe.controlnet.save_pretrained(args.dump_path, safe_serialization=args.to_safetensors)
		else:
				pipe.save_pretrained(args.dump_path, safe_serialization=args.to_safetensors)


