# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import tempfile import paddle paddle.set_device("cpu") import argparse import torch from collections import OrderedDict from diffusers import StableDiffusionPipeline as DiffusersStableDiffusionPipeline from ppdiffusers.configuration_utils import FrozenDict from ppdiffusers import StableDiffusionPipeline as PPDiffusersStableDiffusionPipeline, AutoencoderKL, UNet2DConditionModel, PNDMScheduler, LMSDiscreteScheduler, DDIMScheduler from ppdiffusers.pipelines.stable_diffusion import StableDiffusionSafetyChecker from paddlenlp.transformers import CLIPTextModel, CLIPVisionModel, CLIPTokenizer, CLIPFeatureExtractor def convert_to_ppdiffusers(vae_or_unet, dtype="float32"): need_transpose = [] for k, v in vae_or_unet.named_modules(): if isinstance(v, torch.nn.Linear): need_transpose.append(k + ".weight") new_vae_or_unet = OrderedDict() for k, v in vae_or_unet.state_dict().items(): if k not in need_transpose: new_vae_or_unet[k] = v.cpu().numpy().astype(dtype) else: new_vae_or_unet[k] = v.t().cpu().numpy().astype(dtype) return new_vae_or_unet def convert_hf_clip_to_ppnlp_clip(clip, dtype="float32", is_text_encoder=True): new_model_state = {} transformers2ppnlp = { ".encoder.": ".transformer.", ".layer_norm": ".norm", ".mlp.": ".", ".fc1.": ".linear1.", ".fc2.": ".linear2.", ".final_layer_norm.": ".ln_final.", ".embeddings.": ".", ".position_embedding.": ".positional_embedding.", ".patch_embedding.": ".conv1.", "visual_projection.weight": "vision_projection", "text_projection.weight": "text_projection", ".pre_layrnorm.": ".ln_pre.", ".post_layernorm.": ".ln_post.", ".vision_model.": "." } ignore_value = ["position_ids"] donot_transpose = [ "embeddings", "norm", "concept_embeds", "special_care_embeds" ] for name, value in clip.state_dict().items(): # step1: ignore position_ids if any(i in name for i in ignore_value): continue # step2: transpose nn.Linear weight if value.ndim == 2 and not any(i in name for i in donot_transpose): value = value.t() # step3: hf_name -> ppnlp_name mapping for hf_name, ppnlp_name in transformers2ppnlp.items(): name = name.replace(hf_name, ppnlp_name) # step4: 0d tensor -> 1d tensor if name == "logit_scale": value = value.reshape((1, )) # step5: safety_checker need prefix "clip." if "vision_model" in name: name = "clip." + name new_model_state[name] = value.cpu().numpy().astype(dtype) if is_text_encoder: new_config = { 'max_text_length': clip.config.max_position_embeddings, 'vocab_size': clip.config.vocab_size, 'text_embed_dim': clip.config.hidden_size, 'text_heads': clip.config.num_attention_heads, 'text_layers': clip.config.num_hidden_layers, 'text_hidden_act': clip.config.hidden_act, 'projection_dim': clip.config.projection_dim, 'initializer_range': clip.config.initializer_range, 'initializer_factor': clip.config.initializer_factor, } else: new_config = { 'image_resolution': clip.config.vision_config.image_size, 'vision_layers': clip.config.vision_config.num_hidden_layers, 'vision_heads': clip.config.vision_config.num_attention_heads, 'vision_embed_dim': clip.config.vision_config.hidden_size, 'vision_patch_size': clip.config.vision_config.patch_size, 'vision_mlp_ratio': clip.config.vision_config.intermediate_size // clip.config.vision_config.hidden_size, 'vision_hidden_act': clip.config.vision_config.hidden_act, 'projection_dim': clip.config.projection_dim, } return new_model_state, new_config def convert_diffusers_stable_diffusion_to_ppdiffusers( pretrained_model_name_or_path, output_path=None): # 0. load diffusers pipe and convert to ppdiffusers weights format diffusers_pipe = DiffusersStableDiffusionPipeline.from_pretrained( pretrained_model_name_or_path, use_auth_token=True) vae_state_dict = convert_to_ppdiffusers(diffusers_pipe.vae) unet_state_dict = convert_to_ppdiffusers(diffusers_pipe.unet) text_encoder_state_dict, text_encoder_config = convert_hf_clip_to_ppnlp_clip( diffusers_pipe.text_encoder, is_text_encoder=True) safety_checker_state_dict, safety_checker_config = convert_hf_clip_to_ppnlp_clip( diffusers_pipe.safety_checker, is_text_encoder=False) # 1. vae pp_vae = AutoencoderKL(**diffusers_pipe.vae.config) pp_vae.set_dict(vae_state_dict) # 2. unet pp_unet = UNet2DConditionModel(**diffusers_pipe.unet.config) pp_unet.set_dict(unet_state_dict) # 3. text_encoder pp_text_encoder = CLIPTextModel(**text_encoder_config) pp_text_encoder.set_dict(text_encoder_state_dict) # 4. safety_checker pp_safety_checker = StableDiffusionSafetyChecker( CLIPVisionModel(**safety_checker_config)) pp_safety_checker.set_dict(safety_checker_state_dict) # 5. scheduler beta_start = diffusers_pipe.scheduler.beta_start beta_end = diffusers_pipe.scheduler.beta_end num_train_timesteps = diffusers_pipe.scheduler.num_train_timesteps scheduler_type = diffusers_pipe.scheduler._class_name.lower() if "pndm" in scheduler_type: pp_scheduler = PNDMScheduler( beta_end=beta_end, beta_schedule="scaled_linear", beta_start=beta_start, num_train_timesteps=num_train_timesteps, skip_prk_steps=True, ) elif "lms" in scheduler_type: pp_scheduler = LMSDiscreteScheduler(beta_start=beta_start, beta_end=beta_end, beta_schedule="scaled_linear") elif "ddim" in scheduler_type: pp_scheduler = DDIMScheduler( beta_start=beta_start, beta_end=beta_end, beta_schedule="scaled_linear", clip_sample=False, set_alpha_to_one=False, ) else: raise ValueError(f"Scheduler of type {scheduler_type} doesn't exist!") with tempfile.TemporaryDirectory() as tmpdirname: # 6. feature_extractor diffusers_pipe.feature_extractor.save_pretrained(tmpdirname) pp_feature_extractor = CLIPFeatureExtractor.from_pretrained(tmpdirname) # 7. tokenizer diffusers_pipe.tokenizer.save_pretrained(tmpdirname) pp_tokenizer = CLIPTokenizer.from_pretrained(tmpdirname) # 8. create ppdiffusers pipe paddle_pipe = PPDiffusersStableDiffusionPipeline( vae=pp_vae, text_encoder=pp_text_encoder, tokenizer=pp_tokenizer, unet=pp_unet, safety_checker=pp_safety_checker, feature_extractor=pp_feature_extractor, scheduler=pp_scheduler) if "runwayml/stable-diffusion-inpainting" in pretrained_model_name_or_path: _internal_dict = dict(paddle_pipe._internal_dict) if _internal_dict["_ppdiffusers_version"] == "0.0.0": _internal_dict.update({"_ppdiffusers_version": "0.6.0"}) paddle_pipe._internal_dict = FrozenDict(_internal_dict) # 9. save_pretrained paddle_pipe.save_pretrained(output_path) return paddle_pipe if __name__ == "__main__": parser = argparse.ArgumentParser( description="Pytorch model weights to Paddle model weights.") parser.add_argument( "--pretrained_model_name_or_path", type=str, default="runwayml/stable-diffusion-v1-5", help= "Path to pretrained model or model identifier from huggingface.co/models.", ) parser.add_argument( "--output_path", type=str, default="stable-diffusion-v1-5-ppdiffusers", help="The model output path.", ) args = parser.parse_args() ppdiffusers_pipe = convert_diffusers_stable_diffusion_to_ppdiffusers( args.pretrained_model_name_or_path, args.output_path)