Guest User

Untitled

a guest
Apr 16th, 2024
55
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Python 12.29 KB | None | 0 0
  1. import argparse                                                                                                        
  2. import numpy as np                                                                                                      
  3. import os                                                                                                              
  4. import shutil                                                                                                          
  5. import torch                                                                                                            
  6. import torch.nn.functional as F                                                                                        
  7. from safetensors.torch import safe_open, save_file                                                                      
  8.                                                                                                                        
  9. class BinDataHandler():                                                                                                
  10.     def __init__(self, data):                                                                                          
  11.         self.data = data                                                                                                
  12.                                                                                                                        
  13.     def get_tensor(self, key):                                                                                          
  14.         return self.data[key]                                                                                          
  15.                                                                                                                        
  16. def read_tensors(file_path):                                                                                            
  17.     if isinstance(file_path, dict):                                                                                    
  18.         return BinDataHandler(file_path), set(file_path.keys())                                                        
  19.     if file_path.endswith(".safetensors"):                                                                              
  20.         f = safe_open(file_path, framework="pt", device="cpu")                                                          
  21.         return f, set(f.keys())                                                                                        
  22.     if file_path.endswith(".bin"):                                                                                      
  23.         data = torch.load(file_path, map_location=torch.device('cpu'))                                                  
  24.         f = BinDataHandler(data)                                                                                        
  25.         return f, set(data.keys())                                                                                      
  26.     return None, None                                                                                                  
  27.                                                                                                                        
  28. #TODO values?                                                                                                          
  29. def combine_loras(tensor_map1, tensor_map2, tensor_map3, unet_strength=2.69, enc_strength=1, enc2_strength=1, peft_type="lora"):
  30.     tensor_map = {}                                                                                                    
  31.     if peft_type == 'dora':                                                                                            
  32.         for k in tensor_map1[1]:                                                                                        
  33.             unet_strength=8                                                                                            
  34.             enc_strength=1                                                                                              
  35.             enc2_strength=1                                                                                            
  36.             k2 = k                                                                                                      
  37.             if "lora_unet_up_blocks_0_upsamplers_0_conv" in k:                                                          
  38.                 k2 = k2.replace("lora_unet_up_blocks_0_upsamplers_0_conv", "diffusion_model_output_blocks_2_2_conv")    
  39.             if "lora_unet_up_blocks_1_upsamplers_0_conv" in k:                                                          
  40.                 k2 = k2.replace("lora_unet_up_blocks_1_upsamplers_0_conv", "diffusion_model_output_blocks_5_2_conv")    
  41.             if 'alpha' in k:                                                                                            
  42.                 tensor_map[k]=unet_strength*torch.ones([1])                                                            
  43.                 tensor_map[k2]=unet_strength*torch.ones([1])                                                            
  44.             else:                                                                                                      
  45.                 tensor_map[k]=tensor_map1[0].get_tensor(k)                                                              
  46.                 tensor_map[k2]=tensor_map1[0].get_tensor(k).clone()                                                    
  47.         for k in tensor_map2[1]:                                                                                        
  48.             if 'alpha' in k:                                                                                            
  49.                 tensor_map[k]=enc_strength*torch.ones([1])                                                              
  50.             else:                                                                                                      
  51.                 tensor_map[k]=tensor_map2[0].get_tensor(k)                                                              
  52.         for k in tensor_map3[1]:                                                                                        
  53.             if 'alpha' in k:                                                                                            
  54.                 tensor_map[k]=enc2_strength*torch.ones([1])                                                            
  55.             else:                                                                                                      
  56.                 tensor_map[k]=tensor_map3[0].get_tensor(k)                                                              
  57.     else:                                                                                                              
  58.         for k in tensor_map1[1]:                                                                                        
  59.             k2 = k                                                                                                      
  60.             if "lora_unet_up_blocks_0_upsamplers_0_conv" in k:                                                          
  61.                 k2 = k2.replace("lora_unet_up_blocks_0_upsamplers_0_conv", "diffusion_model_output_blocks_2_2_conv")    
  62.             if "lora_unet_up_blocks_1_upsamplers_0_conv" in k:                                                          
  63.                 k2 = k2.replace("lora_unet_up_blocks_1_upsamplers_0_conv", "diffusion_model_output_blocks_5_2_conv")    
  64.             if 'alpha' in k:                                                                                            
  65.                 tensor_map[k2]=torch.ones([1])                                                                          
  66.                 tensor_map[k]=torch.ones([1])                                                                          
  67.             else:                                                                                                      
  68.                 tensor_map[k2]=unet_strength*tensor_map1[0].get_tensor(k)                                              
  69.                 tensor_map[k]=unet_strength*tensor_map1[0].get_tensor(k)                                                
  70.         for k in tensor_map2[1]:                                                                                        
  71.             if 'alpha' in k:                                                                                            
  72.                 tensor_map[k]=torch.ones([1])                                                                          
  73.             else:                                                                                                      
  74.                 tensor_map[k]=enc_strength* tensor_map2[0].get_tensor(k)                                                
  75.         for k in tensor_map3[1]:                                                                                        
  76.             if 'alpha' in k:                                                                                            
  77.                 tensor_map[k]=torch.ones([1])                                                                          
  78.             else:                                                                                                      
  79.                 tensor_map[k]=enc2_strength*tensor_map3[0].get_tensor(k)                                                
  80.                                                                                                                        
  81.     return tensor_map                                                                                                  
  82.                                                                                                                        
  83. def main():                                                                                                            
  84.     # Parse command-line arguments                                                                                      
  85.     parser = argparse.ArgumentParser(description='Merge two safetensor model files.')                                  
  86.     parser.add_argument('unet_model', type=str, help='The unet model safetensor file')                                  
  87.     parser.add_argument('encoder1_model', type=str, help='The encoder1 model safetensor file')                          
  88.     parser.add_argument('encoder2_model', type=str, help='The encoder2 model safetensor file')                          
  89.     parser.add_argument('output_model', type=str, help='The output merged model safetensor file')                      
  90.     parser.add_argument('unet_strength', type=float, default=0.8, help='Strength of the unet')                          
  91.     parser.add_argument('enc_strength', type=float, default=1, help='Strength of the unet')                            
  92.     parser.add_argument('enc2_strength', type=float, default=1, help='Strength of the unet')                            
  93.     args = parser.parse_args()                                                                                          
  94.                                                                                                                        
  95.     tensor_map1 = read_tensors(args.unet_model)                                                                        
  96.     tensor_map2 = read_tensors(args.encoder1_model)                                                                    
  97.     tensor_map3 = read_tensors(args.encoder2_model)                                                                    
  98.     tensor_map = combine_loras(tensor_map1, tensor_map2, tensor_map3, args.unet_strength, args.enc_strength, args.enc_strength2)
  99.                                                                                                                        
  100.     save_file(tensor_map, args.output_model)                                                                            
  101.                                                                                                                        
  102. if __name__ == '__main__':                                                                                              
  103.     main()                                                                                                              
  104.  
Advertisement
Add Comment
Please, Sign In to add comment