Add files via upload
add
This commit is contained in:
smthemex
@@ -0,0 +1,519 @@
|
||||
from calendar import c
|
||||
from operator import invert
|
||||
from webbrowser import get
|
||||
import torch
|
||||
import random
|
||||
import torch.nn as nn
|
||||
import torch.nn.functional as F
|
||||
import gradio as gr
|
||||
|
||||
class SpatialAttnProcessor2_0(torch.nn.Module):
|
||||
r"""
|
||||
Attention processor for IP-Adapater for PyTorch 2.0.
|
||||
Args:
|
||||
hidden_size (`int`):
|
||||
The hidden size of the attention layer.
|
||||
cross_attention_dim (`int`):
|
||||
The number of channels in the `encoder_hidden_states`.
|
||||
text_context_len (`int`, defaults to 77):
|
||||
The context length of the text features.
|
||||
scale (`float`, defaults to 1.0):
|
||||
the weight scale of image prompt.
|
||||
"""
|
||||
|
||||
def __init__(self, hidden_size = None, cross_attention_dim=None,id_length = 4,device = "cuda",dtype = torch.float16):
|
||||
super().__init__()
|
||||
if not hasattr(F, "scaled_dot_product_attention"):
|
||||
raise ImportError("AttnProcessor2_0 requires PyTorch 2.0, to use it, please upgrade PyTorch to 2.0.")
|
||||
self.device = device
|
||||
self.dtype = dtype
|
||||
self.hidden_size = hidden_size
|
||||
self.cross_attention_dim = cross_attention_dim
|
||||
self.total_length = id_length + 1
|
||||
self.id_length = id_length
|
||||
self.id_bank = {}
|
||||
|
||||
def __call__(
|
||||
self,
|
||||
attn,
|
||||
hidden_states,
|
||||
encoder_hidden_states=None,
|
||||
attention_mask=None,
|
||||
temb=None):
|
||||
# un_cond_hidden_states, cond_hidden_states = hidden_states.chunk(2)
|
||||
# un_cond_hidden_states = self.__call2__(attn, un_cond_hidden_states,encoder_hidden_states,attention_mask,temb)
|
||||
# 生成一个0到1之间的随机数
|
||||
global total_count,attn_count,cur_step,mask256,mask1024,mask4096
|
||||
global sa16, sa32, sa64
|
||||
global write
|
||||
if write:
|
||||
self.id_bank[cur_step] = [hidden_states[:self.id_length], hidden_states[self.id_length:]]
|
||||
else:
|
||||
encoder_hidden_states = torch.cat(self.id_bank[cur_step][0],hidden_states[:1],self.id_bank[cur_step][1],hidden_states[1:])
|
||||
# 判断随机数是否大于0.5
|
||||
if cur_step <5:
|
||||
hidden_states = self.__call2__(attn, hidden_states,encoder_hidden_states,attention_mask,temb)
|
||||
else: # 256 1024 4096
|
||||
random_number = random.random()
|
||||
if cur_step <20:
|
||||
rand_num = 0.3
|
||||
else:
|
||||
rand_num = 0.1
|
||||
if random_number > rand_num:
|
||||
if not write:
|
||||
if hidden_states.shape[1] == 32* 32:
|
||||
attention_mask = mask1024[mask1024.shape[0] // self.total_length * self.id_length:]
|
||||
elif hidden_states.shape[1] ==16*16:
|
||||
attention_mask = mask256[mask256.shape[0] // self.total_length * self.id_length:]
|
||||
else:
|
||||
attention_mask = mask4096[mask4096.shape[0] // self.total_length * self.id_length:]
|
||||
else:
|
||||
if hidden_states.shape[1] == 32* 32:
|
||||
attention_mask = mask1024[:mask1024.shape[0] // self.total_length * self.id_length]
|
||||
elif hidden_states.shape[1] ==16*16:
|
||||
attention_mask = mask256[:mask256.shape[0] // self.total_length * self.id_length]
|
||||
else:
|
||||
attention_mask = mask4096[:mask4096.shape[0] // self.total_length * self.id_length]
|
||||
hidden_states = self.__call1__(attn, hidden_states,encoder_hidden_states,attention_mask,temb)
|
||||
else:
|
||||
hidden_states = self.__call2__(attn, hidden_states,None,attention_mask,temb)
|
||||
attn_count +=1
|
||||
if attn_count == total_count:
|
||||
attn_count = 0
|
||||
cur_step += 1
|
||||
mask256,mask1024,mask4096 = cal_attn_mask(self.total_length,self.id_length,sa16,sa32,sa64, device=self.device, dtype= self.dtype)
|
||||
|
||||
return hidden_states
|
||||
def __call1__(
|
||||
self,
|
||||
attn,
|
||||
hidden_states,
|
||||
encoder_hidden_states=None,
|
||||
attention_mask=None,
|
||||
temb=None,
|
||||
):
|
||||
residual = hidden_states
|
||||
if encoder_hidden_states is not None:
|
||||
raise Exception("not implement")
|
||||
if attn.spatial_norm is not None:
|
||||
hidden_states = attn.spatial_norm(hidden_states, temb)
|
||||
input_ndim = hidden_states.ndim
|
||||
|
||||
if input_ndim == 4:
|
||||
total_batch_size, channel, height, width = hidden_states.shape
|
||||
hidden_states = hidden_states.view(total_batch_size, channel, height * width).transpose(1, 2)
|
||||
total_batch_size,nums_token,channel = hidden_states.shape
|
||||
img_nums = total_batch_size//2
|
||||
hidden_states = hidden_states.view(-1,img_nums,nums_token,channel).reshape(-1,img_nums * nums_token,channel)
|
||||
|
||||
batch_size, sequence_length, _ = hidden_states.shape
|
||||
|
||||
if attn.group_norm is not None:
|
||||
hidden_states = attn.group_norm(hidden_states.transpose(1, 2)).transpose(1, 2)
|
||||
|
||||
query = attn.to_q(hidden_states)
|
||||
|
||||
if encoder_hidden_states is None:
|
||||
encoder_hidden_states = hidden_states # B, N, C
|
||||
else:
|
||||
encoder_hidden_states = encoder_hidden_states.view(-1,self.id_length+1,nums_token,channel).reshape(-1,(self.id_length+1) * nums_token,channel)
|
||||
|
||||
key = attn.to_k(encoder_hidden_states)
|
||||
value = attn.to_v(encoder_hidden_states)
|
||||
|
||||
|
||||
inner_dim = key.shape[-1]
|
||||
head_dim = inner_dim // attn.heads
|
||||
|
||||
query = query.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
|
||||
|
||||
key = key.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
|
||||
value = value.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
|
||||
|
||||
# the output of sdp = (batch, num_heads, seq_len, head_dim)
|
||||
# TODO: add support for attn.scale when we move to Torch 2.1
|
||||
hidden_states = F.scaled_dot_product_attention(
|
||||
query, key, value, attn_mask=attention_mask, dropout_p=0.0, is_causal=False
|
||||
)
|
||||
|
||||
hidden_states = hidden_states.transpose(1, 2).reshape(batch_size, -1, attn.heads * head_dim)
|
||||
hidden_states = hidden_states.to(query.dtype)
|
||||
|
||||
|
||||
|
||||
# linear proj
|
||||
hidden_states = attn.to_out[0](hidden_states)
|
||||
# dropout
|
||||
hidden_states = attn.to_out[1](hidden_states)
|
||||
|
||||
# if input_ndim == 4:
|
||||
# tile_hidden_states = tile_hidden_states.transpose(-1, -2).reshape(batch_size, channel, height, width)
|
||||
|
||||
# if attn.residual_connection:
|
||||
# tile_hidden_states = tile_hidden_states + residual
|
||||
|
||||
if input_ndim == 4:
|
||||
hidden_states = hidden_states.transpose(-1, -2).reshape(total_batch_size, channel, height, width)
|
||||
if attn.residual_connection:
|
||||
hidden_states = hidden_states + residual
|
||||
hidden_states = hidden_states / attn.rescale_output_factor
|
||||
|
||||
return hidden_states
|
||||
def __call2__(
|
||||
self,
|
||||
attn,
|
||||
hidden_states,
|
||||
encoder_hidden_states=None,
|
||||
attention_mask=None,
|
||||
temb=None):
|
||||
residual = hidden_states
|
||||
|
||||
if attn.spatial_norm is not None:
|
||||
hidden_states = attn.spatial_norm(hidden_states, temb)
|
||||
|
||||
input_ndim = hidden_states.ndim
|
||||
|
||||
if input_ndim == 4:
|
||||
batch_size, channel, height, width = hidden_states.shape
|
||||
hidden_states = hidden_states.view(batch_size, channel, height * width).transpose(1, 2)
|
||||
|
||||
batch_size, sequence_length, _ = (
|
||||
hidden_states.shape if encoder_hidden_states is None else encoder_hidden_states.shape
|
||||
)
|
||||
attention_mask = attn.prepare_attention_mask(attention_mask, sequence_length, batch_size)
|
||||
|
||||
if attn.group_norm is not None:
|
||||
hidden_states = attn.group_norm(hidden_states.transpose(1, 2)).transpose(1, 2)
|
||||
|
||||
query = attn.to_q(hidden_states)
|
||||
|
||||
if encoder_hidden_states is None:
|
||||
encoder_hidden_states = hidden_states
|
||||
elif attn.norm_cross:
|
||||
encoder_hidden_states = attn.norm_encoder_hidden_states(encoder_hidden_states)
|
||||
|
||||
key = attn.to_k(encoder_hidden_states)
|
||||
value = attn.to_v(encoder_hidden_states)
|
||||
|
||||
query = attn.head_to_batch_dim(query)
|
||||
key = attn.head_to_batch_dim(key)
|
||||
value = attn.head_to_batch_dim(value)
|
||||
|
||||
attention_probs = attn.get_attention_scores(query, key, attention_mask)
|
||||
hidden_states = torch.bmm(attention_probs, value)
|
||||
hidden_states = attn.batch_to_head_dim(hidden_states)
|
||||
|
||||
# linear proj
|
||||
hidden_states = attn.to_out[0](hidden_states)
|
||||
# dropout
|
||||
hidden_states = attn.to_out[1](hidden_states)
|
||||
|
||||
if input_ndim == 4:
|
||||
hidden_states = hidden_states.transpose(-1, -2).reshape(batch_size, channel, height, width)
|
||||
|
||||
if attn.residual_connection:
|
||||
hidden_states = hidden_states + residual
|
||||
|
||||
hidden_states = hidden_states / attn.rescale_output_factor
|
||||
|
||||
return hidden_states
|
||||
|
||||
|
||||
def cal_attn_mask(total_length,id_length,sa16,sa32,sa64,device="cuda",dtype= torch.float16):
|
||||
bool_matrix256 = torch.rand((1, total_length * 256),device = device,dtype = dtype) < sa16
|
||||
bool_matrix1024 = torch.rand((1, total_length * 1024),device = device,dtype = dtype) < sa32
|
||||
bool_matrix4096 = torch.rand((1, total_length * 4096),device = device,dtype = dtype) < sa64
|
||||
bool_matrix256 = bool_matrix256.repeat(total_length,1)
|
||||
bool_matrix1024 = bool_matrix1024.repeat(total_length,1)
|
||||
bool_matrix4096 = bool_matrix4096.repeat(total_length,1)
|
||||
for i in range(total_length):
|
||||
bool_matrix256[i:i+1,id_length*256:] = False
|
||||
bool_matrix1024[i:i+1,id_length*1024:] = False
|
||||
bool_matrix4096[i:i+1,id_length*4096:] = False
|
||||
bool_matrix256[i:i+1,i*256:(i+1)*256] = True
|
||||
bool_matrix1024[i:i+1,i*1024:(i+1)*1024] = True
|
||||
bool_matrix4096[i:i+1,i*4096:(i+1)*4096] = True
|
||||
mask256 = bool_matrix256.unsqueeze(1).repeat(1,256,1).reshape(-1,total_length * 256)
|
||||
mask1024 = bool_matrix1024.unsqueeze(1).repeat(1,1024,1).reshape(-1,total_length * 1024)
|
||||
mask4096 = bool_matrix4096.unsqueeze(1).repeat(1,4096,1).reshape(-1,total_length * 4096)
|
||||
return mask256,mask1024,mask4096
|
||||
|
||||
def cal_attn_mask_xl(total_length,id_length,sa32,sa64,height,width,device="cuda",dtype= torch.float16):
|
||||
nums_1024 = (height // 32) * (width // 32)
|
||||
nums_4096 = (height // 16) * (width // 16)
|
||||
bool_matrix1024 = torch.rand((1, total_length * nums_1024),device = device,dtype = dtype) < sa32
|
||||
bool_matrix4096 = torch.rand((1, total_length * nums_4096),device = device,dtype = dtype) < sa64
|
||||
bool_matrix1024 = bool_matrix1024.repeat(total_length,1)
|
||||
bool_matrix4096 = bool_matrix4096.repeat(total_length,1)
|
||||
for i in range(total_length):
|
||||
bool_matrix1024[i:i+1,id_length*nums_1024:] = False
|
||||
bool_matrix4096[i:i+1,id_length*nums_4096:] = False
|
||||
bool_matrix1024[i:i+1,i*nums_1024:(i+1)*nums_1024] = True
|
||||
bool_matrix4096[i:i+1,i*nums_4096:(i+1)*nums_4096] = True
|
||||
mask1024 = bool_matrix1024.unsqueeze(1).repeat(1,nums_1024,1).reshape(-1,total_length * nums_1024)
|
||||
mask4096 = bool_matrix4096.unsqueeze(1).repeat(1,nums_4096,1).reshape(-1,total_length * nums_4096)
|
||||
return mask1024,mask4096
|
||||
|
||||
|
||||
def cal_attn_indice_xl_effcient_memory(total_length,id_length,sa32,sa64,height,width,device="cuda",dtype= torch.float16):
|
||||
nums_1024 = (height // 32) * (width // 32)
|
||||
nums_4096 = (height // 16) * (width // 16)
|
||||
bool_matrix1024 = torch.rand((total_length,nums_1024),device = device,dtype = dtype) < sa32
|
||||
bool_matrix4096 = torch.rand((total_length,nums_4096),device = device,dtype = dtype) < sa64
|
||||
# 用nonzero()函数获取所有为True的值的索引
|
||||
indices1024 = [torch.nonzero(bool_matrix1024[i], as_tuple=True)[0] for i in range(total_length)]
|
||||
indices4096 = [torch.nonzero(bool_matrix4096[i], as_tuple=True)[0] for i in range(total_length)]
|
||||
|
||||
return indices1024,indices4096
|
||||
|
||||
|
||||
class AttnProcessor(nn.Module):
|
||||
r"""
|
||||
Default processor for performing attention-related computations.
|
||||
"""
|
||||
def __init__(
|
||||
self,
|
||||
hidden_size=None,
|
||||
cross_attention_dim=None,
|
||||
):
|
||||
super().__init__()
|
||||
|
||||
def __call__(
|
||||
self,
|
||||
attn,
|
||||
hidden_states,
|
||||
encoder_hidden_states=None,
|
||||
attention_mask=None,
|
||||
temb=None,
|
||||
):
|
||||
residual = hidden_states
|
||||
|
||||
if attn.spatial_norm is not None:
|
||||
hidden_states = attn.spatial_norm(hidden_states, temb)
|
||||
|
||||
input_ndim = hidden_states.ndim
|
||||
|
||||
if input_ndim == 4:
|
||||
batch_size, channel, height, width = hidden_states.shape
|
||||
hidden_states = hidden_states.view(batch_size, channel, height * width).transpose(1, 2)
|
||||
|
||||
batch_size, sequence_length, _ = (
|
||||
hidden_states.shape if encoder_hidden_states is None else encoder_hidden_states.shape
|
||||
)
|
||||
attention_mask = attn.prepare_attention_mask(attention_mask, sequence_length, batch_size)
|
||||
|
||||
if attn.group_norm is not None:
|
||||
hidden_states = attn.group_norm(hidden_states.transpose(1, 2)).transpose(1, 2)
|
||||
|
||||
query = attn.to_q(hidden_states)
|
||||
|
||||
if encoder_hidden_states is None:
|
||||
encoder_hidden_states = hidden_states
|
||||
elif attn.norm_cross:
|
||||
encoder_hidden_states = attn.norm_encoder_hidden_states(encoder_hidden_states)
|
||||
|
||||
key = attn.to_k(encoder_hidden_states)
|
||||
value = attn.to_v(encoder_hidden_states)
|
||||
|
||||
query = attn.head_to_batch_dim(query)
|
||||
key = attn.head_to_batch_dim(key)
|
||||
value = attn.head_to_batch_dim(value)
|
||||
|
||||
attention_probs = attn.get_attention_scores(query, key, attention_mask)
|
||||
hidden_states = torch.bmm(attention_probs, value)
|
||||
hidden_states = attn.batch_to_head_dim(hidden_states)
|
||||
|
||||
# linear proj
|
||||
hidden_states = attn.to_out[0](hidden_states)
|
||||
# dropout
|
||||
hidden_states = attn.to_out[1](hidden_states)
|
||||
|
||||
if input_ndim == 4:
|
||||
hidden_states = hidden_states.transpose(-1, -2).reshape(batch_size, channel, height, width)
|
||||
|
||||
if attn.residual_connection:
|
||||
hidden_states = hidden_states + residual
|
||||
|
||||
hidden_states = hidden_states / attn.rescale_output_factor
|
||||
|
||||
return hidden_states
|
||||
|
||||
|
||||
class AttnProcessor2_0(torch.nn.Module):
|
||||
r"""
|
||||
Processor for implementing scaled dot-product attention (enabled by default if you're using PyTorch 2.0).
|
||||
"""
|
||||
def __init__(
|
||||
self,
|
||||
hidden_size=None,
|
||||
cross_attention_dim=None,
|
||||
):
|
||||
super().__init__()
|
||||
if not hasattr(F, "scaled_dot_product_attention"):
|
||||
raise ImportError("AttnProcessor2_0 requires PyTorch 2.0, to use it, please upgrade PyTorch to 2.0.")
|
||||
|
||||
def __call__(
|
||||
self,
|
||||
attn,
|
||||
hidden_states,
|
||||
encoder_hidden_states=None,
|
||||
attention_mask=None,
|
||||
temb=None,
|
||||
):
|
||||
residual = hidden_states
|
||||
|
||||
if attn.spatial_norm is not None:
|
||||
hidden_states = attn.spatial_norm(hidden_states, temb)
|
||||
|
||||
input_ndim = hidden_states.ndim
|
||||
|
||||
if input_ndim == 4:
|
||||
batch_size, channel, height, width = hidden_states.shape
|
||||
hidden_states = hidden_states.view(batch_size, channel, height * width).transpose(1, 2)
|
||||
|
||||
batch_size, sequence_length, _ = (
|
||||
hidden_states.shape if encoder_hidden_states is None else encoder_hidden_states.shape
|
||||
)
|
||||
|
||||
if attention_mask is not None:
|
||||
attention_mask = attn.prepare_attention_mask(attention_mask, sequence_length, batch_size)
|
||||
# scaled_dot_product_attention expects attention_mask shape to be
|
||||
# (batch, heads, source_length, target_length)
|
||||
attention_mask = attention_mask.view(batch_size, attn.heads, -1, attention_mask.shape[-1])
|
||||
|
||||
if attn.group_norm is not None:
|
||||
hidden_states = attn.group_norm(hidden_states.transpose(1, 2)).transpose(1, 2)
|
||||
|
||||
query = attn.to_q(hidden_states)
|
||||
|
||||
if encoder_hidden_states is None:
|
||||
encoder_hidden_states = hidden_states
|
||||
elif attn.norm_cross:
|
||||
encoder_hidden_states = attn.norm_encoder_hidden_states(encoder_hidden_states)
|
||||
|
||||
key = attn.to_k(encoder_hidden_states)
|
||||
value = attn.to_v(encoder_hidden_states)
|
||||
|
||||
inner_dim = key.shape[-1]
|
||||
head_dim = inner_dim // attn.heads
|
||||
|
||||
query = query.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
|
||||
|
||||
key = key.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
|
||||
value = value.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
|
||||
|
||||
# the output of sdp = (batch, num_heads, seq_len, head_dim)
|
||||
# TODO: add support for attn.scale when we move to Torch 2.1
|
||||
hidden_states = F.scaled_dot_product_attention(
|
||||
query, key, value, attn_mask=attention_mask, dropout_p=0.0, is_causal=False
|
||||
)
|
||||
|
||||
hidden_states = hidden_states.transpose(1, 2).reshape(batch_size, -1, attn.heads * head_dim)
|
||||
hidden_states = hidden_states.to(query.dtype)
|
||||
|
||||
# linear proj
|
||||
hidden_states = attn.to_out[0](hidden_states)
|
||||
# dropout
|
||||
hidden_states = attn.to_out[1](hidden_states)
|
||||
|
||||
if input_ndim == 4:
|
||||
hidden_states = hidden_states.transpose(-1, -2).reshape(batch_size, channel, height, width)
|
||||
|
||||
if attn.residual_connection:
|
||||
hidden_states = hidden_states + residual
|
||||
|
||||
hidden_states = hidden_states / attn.rescale_output_factor
|
||||
|
||||
return hidden_states
|
||||
|
||||
|
||||
def is_torch2_available():
|
||||
return hasattr(F, "scaled_dot_product_attention")
|
||||
|
||||
|
||||
# 将列表转换为字典的函数
|
||||
def character_to_dict(general_prompt):
|
||||
character_dict = {}
|
||||
generate_prompt_arr = general_prompt.splitlines()
|
||||
character_index_dict = {}
|
||||
invert_character_index_dict = {}
|
||||
character_list = []
|
||||
for ind,string in enumerate(generate_prompt_arr):
|
||||
# 分割字符串寻找key和value
|
||||
start = string.find('[')
|
||||
end = string.find(']')
|
||||
if start != -1 and end != -1:
|
||||
key = string[start:end+1]
|
||||
value = string[end+1:]
|
||||
if "#" in value:
|
||||
value = value.rpartition('#')[0]
|
||||
if key in character_dict:
|
||||
raise gr.Error("duplicate character descirption: " + key)
|
||||
character_dict[key] = value
|
||||
character_list.append(key)
|
||||
|
||||
|
||||
return character_dict,character_list
|
||||
|
||||
def get_id_prompt_index(character_dict,id_prompts):
|
||||
replace_id_prompts = []
|
||||
character_index_dict = {}
|
||||
invert_character_index_dict = {}
|
||||
for ind,id_prompt in enumerate(id_prompts):
|
||||
for key in character_dict.keys():
|
||||
if key in id_prompt:
|
||||
if key not in character_index_dict:
|
||||
character_index_dict[key] = []
|
||||
character_index_dict[key].append(ind)
|
||||
invert_character_index_dict[ind] = key
|
||||
replace_id_prompts.append(id_prompt.replace(key,character_dict[key]))
|
||||
|
||||
return character_index_dict,invert_character_index_dict,replace_id_prompts
|
||||
|
||||
def get_cur_id_list(real_prompt,character_dict,character_index_dict):
|
||||
list_arr = []
|
||||
for keys in character_index_dict.keys():
|
||||
if keys in real_prompt:
|
||||
list_arr = list_arr + character_index_dict[keys]
|
||||
real_prompt = real_prompt.replace(keys,character_dict[keys])
|
||||
return list_arr,real_prompt
|
||||
|
||||
def process_original_prompt(character_dict,prompts,id_length):
|
||||
replace_prompts = []
|
||||
character_index_dict = {}
|
||||
invert_character_index_dict = {}
|
||||
for ind,prompt in enumerate(prompts):
|
||||
for key in character_dict.keys():
|
||||
if key in prompt:
|
||||
if key not in character_index_dict:
|
||||
character_index_dict[key] = []
|
||||
character_index_dict[key].append(ind)
|
||||
if ind not in invert_character_index_dict:
|
||||
invert_character_index_dict[ind] = []
|
||||
invert_character_index_dict[ind].append(key)
|
||||
cur_prompt = prompt
|
||||
if ind in invert_character_index_dict:
|
||||
for key in invert_character_index_dict[ind]:
|
||||
cur_prompt = cur_prompt.replace(key,character_dict[key] + " ")
|
||||
replace_prompts.append(cur_prompt)
|
||||
ref_index_dict = {}
|
||||
ref_totals = []
|
||||
print(character_index_dict)
|
||||
for character_key in character_index_dict.keys():
|
||||
if character_key not in character_index_dict:
|
||||
raise gr.Error("{} not have prompt description, please remove it".format(character_key))
|
||||
index_list = character_index_dict[character_key]
|
||||
index_list = [index for index in index_list if len(invert_character_index_dict[index]) == 1]
|
||||
if len(index_list) < id_length:
|
||||
raise gr.Error(f"{character_key} not have enough prompt description, need no less than {id_length}, but you give {len(index_list)}")
|
||||
ref_index_dict[character_key] = index_list[:id_length]
|
||||
ref_totals = ref_totals + index_list[:id_length]
|
||||
return character_index_dict,invert_character_index_dict,replace_prompts,ref_index_dict,ref_totals
|
||||
|
||||
|
||||
def get_ref_character(real_prompt,character_dict):
|
||||
list_arr = []
|
||||
for keys in character_dict.keys():
|
||||
if keys in real_prompt:
|
||||
list_arr = list_arr + [keys]
|
||||
return list_arr
|
||||
@@ -0,0 +1,62 @@
|
||||
import yaml
|
||||
import torch
|
||||
from diffusers import StableDiffusionXLPipeline
|
||||
from .pipeline import PhotoMakerStableDiffusionXLPipeline
|
||||
import os
|
||||
|
||||
dir_path = os.path.dirname(os.path.abspath(__file__))
|
||||
path_dir = os.path.dirname(dir_path)
|
||||
file_path = os.path.dirname(path_dir)
|
||||
yaml_path = os.path.join(path_dir ,'config/models.yaml')
|
||||
|
||||
def get_models_dict():
|
||||
# 打开并读取YAML文件
|
||||
with open(yaml_path, 'r') as stream:
|
||||
try:
|
||||
# 解析YAML文件内容
|
||||
data = yaml.safe_load(stream)
|
||||
|
||||
# 此时 'data' 是一个Python字典，里面包含了YAML文件的所有数据
|
||||
#print(data)
|
||||
return data
|
||||
|
||||
except yaml.YAMLError as exc:
|
||||
# 如果在解析过程中发生了错误，打印异常信息
|
||||
print(exc)
|
||||
|
||||
def load_models(model_info,device,photomaker_path):
|
||||
path = model_info["path"]
|
||||
single_files = model_info["single_files"]
|
||||
use_safetensors = model_info["use_safetensors"]
|
||||
model_type = model_info["model_type"]
|
||||
|
||||
if model_type == "original":
|
||||
if single_files:
|
||||
pipe = StableDiffusionXLPipeline.from_single_file(
|
||||
path,
|
||||
torch_dtype=torch.float16
|
||||
)
|
||||
else:
|
||||
pipe = StableDiffusionXLPipeline.from_pretrained(path, torch_dtype=torch.float16, use_safetensors=use_safetensors)
|
||||
pipe = pipe.to(device)
|
||||
elif model_type == "Photomaker":
|
||||
if single_files:
|
||||
print("loading from a single_files")
|
||||
pipe = PhotoMakerStableDiffusionXLPipeline.from_single_file(
|
||||
path,
|
||||
torch_dtype=torch.float16
|
||||
)
|
||||
else:
|
||||
pipe = PhotoMakerStableDiffusionXLPipeline.from_pretrained(
|
||||
path, torch_dtype=torch.float16, use_safetensors=use_safetensors)
|
||||
pipe = pipe.to(device)
|
||||
pipe.load_photomaker_adapter(
|
||||
os.path.dirname(photomaker_path),
|
||||
subfolder="",
|
||||
weight_name=os.path.basename(photomaker_path),
|
||||
trigger_word="img" # define the trigger word
|
||||
)
|
||||
pipe.fuse_lora()
|
||||
else:
|
||||
raise NotImplementedError("You should choice between original and Photomaker!",f"But you choice {model_type}")
|
||||
return pipe
|
||||
+113
@@ -0,0 +1,113 @@
|
||||
# Merge image encoder and fuse module to create an ID Encoder
|
||||
# send multiple ID images, we can directly obtain the updated text encoder containing a stacked ID embedding
|
||||
|
||||
import torch
|
||||
import torch.nn as nn
|
||||
from transformers.models.clip.modeling_clip import CLIPVisionModelWithProjection
|
||||
from transformers.models.clip.configuration_clip import CLIPVisionConfig
|
||||
from transformers import PretrainedConfig
|
||||
|
||||
VISION_CONFIG_DICT = {
|
||||
"hidden_size": 1024,
|
||||
"intermediate_size": 4096,
|
||||
"num_attention_heads": 16,
|
||||
"num_hidden_layers": 24,
|
||||
"patch_size": 14,
|
||||
"projection_dim": 768
|
||||
}
|
||||
|
||||
class MLP(nn.Module):
|
||||
def __init__(self, in_dim, out_dim, hidden_dim, use_residual=True):
|
||||
super().__init__()
|
||||
if use_residual:
|
||||
assert in_dim == out_dim
|
||||
self.layernorm = nn.LayerNorm(in_dim)
|
||||
self.fc1 = nn.Linear(in_dim, hidden_dim)
|
||||
self.fc2 = nn.Linear(hidden_dim, out_dim)
|
||||
self.use_residual = use_residual
|
||||
self.act_fn = nn.GELU()
|
||||
|
||||
def forward(self, x):
|
||||
residual = x
|
||||
x = self.layernorm(x)
|
||||
x = self.fc1(x)
|
||||
x = self.act_fn(x)
|
||||
x = self.fc2(x)
|
||||
if self.use_residual:
|
||||
x = x + residual
|
||||
return x
|
||||
|
||||
|
||||
class FuseModule(nn.Module):
|
||||
def __init__(self, embed_dim):
|
||||
super().__init__()
|
||||
self.mlp1 = MLP(embed_dim * 2, embed_dim, embed_dim, use_residual=False)
|
||||
self.mlp2 = MLP(embed_dim, embed_dim, embed_dim, use_residual=True)
|
||||
self.layer_norm = nn.LayerNorm(embed_dim)
|
||||
|
||||
def fuse_fn(self, prompt_embeds, id_embeds):
|
||||
stacked_id_embeds = torch.cat([prompt_embeds, id_embeds], dim=-1)
|
||||
stacked_id_embeds = self.mlp1(stacked_id_embeds) + prompt_embeds
|
||||
stacked_id_embeds = self.mlp2(stacked_id_embeds)
|
||||
stacked_id_embeds = self.layer_norm(stacked_id_embeds)
|
||||
return stacked_id_embeds
|
||||
|
||||
def forward(
|
||||
self,
|
||||
prompt_embeds,
|
||||
id_embeds,
|
||||
class_tokens_mask,
|
||||
) -> torch.Tensor:
|
||||
# id_embeds shape: [b, max_num_inputs, 1, 2048]
|
||||
id_embeds = id_embeds.to(prompt_embeds.dtype)
|
||||
num_inputs = class_tokens_mask.sum().unsqueeze(0) # TODO: check for training case
|
||||
batch_size, max_num_inputs = id_embeds.shape[:2]
|
||||
# seq_length: 77
|
||||
seq_length = prompt_embeds.shape[1]
|
||||
# flat_id_embeds shape: [b*max_num_inputs, 1, 2048]
|
||||
flat_id_embeds = id_embeds.view(
|
||||
-1, id_embeds.shape[-2], id_embeds.shape[-1]
|
||||
)
|
||||
# valid_id_mask [b*max_num_inputs]
|
||||
valid_id_mask = (
|
||||
torch.arange(max_num_inputs, device=flat_id_embeds.device)[None, :]
|
||||
< num_inputs[:, None]
|
||||
)
|
||||
valid_id_embeds = flat_id_embeds[valid_id_mask.flatten()]
|
||||
|
||||
prompt_embeds = prompt_embeds.view(-1, prompt_embeds.shape[-1])
|
||||
class_tokens_mask = class_tokens_mask.view(-1)
|
||||
valid_id_embeds = valid_id_embeds.view(-1, valid_id_embeds.shape[-1])
|
||||
# slice out the image token embeddings
|
||||
image_token_embeds = prompt_embeds[class_tokens_mask]
|
||||
stacked_id_embeds = self.fuse_fn(image_token_embeds, valid_id_embeds)
|
||||
assert class_tokens_mask.sum() == stacked_id_embeds.shape[0], f"{class_tokens_mask.sum()} != {stacked_id_embeds.shape[0]}"
|
||||
prompt_embeds.masked_scatter_(class_tokens_mask[:, None], stacked_id_embeds.to(prompt_embeds.dtype))
|
||||
updated_prompt_embeds = prompt_embeds.view(batch_size, seq_length, -1)
|
||||
return updated_prompt_embeds
|
||||
|
||||
class PhotoMakerIDEncoder(CLIPVisionModelWithProjection):
|
||||
def __init__(self):
|
||||
super().__init__(CLIPVisionConfig(**VISION_CONFIG_DICT))
|
||||
self.visual_projection_2 = nn.Linear(1024, 1280, bias=False)
|
||||
self.fuse_module = FuseModule(2048)
|
||||
|
||||
def forward(self, id_pixel_values, prompt_embeds, class_tokens_mask):
|
||||
b, num_inputs, c, h, w = id_pixel_values.shape
|
||||
id_pixel_values = id_pixel_values.view(b * num_inputs, c, h, w)
|
||||
|
||||
shared_id_embeds = self.vision_model(id_pixel_values)[1]
|
||||
id_embeds = self.visual_projection(shared_id_embeds)
|
||||
id_embeds_2 = self.visual_projection_2(shared_id_embeds)
|
||||
|
||||
id_embeds = id_embeds.view(b, num_inputs, 1, -1)
|
||||
id_embeds_2 = id_embeds_2.view(b, num_inputs, 1, -1)
|
||||
|
||||
id_embeds = torch.cat((id_embeds, id_embeds_2), dim=-1)
|
||||
updated_prompt_embeds = self.fuse_module(prompt_embeds, id_embeds, class_tokens_mask)
|
||||
|
||||
return updated_prompt_embeds
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
PhotoMakerIDEncoder()
|
||||
@@ -0,0 +1,588 @@
|
||||
from typing import Any, Callable, Dict, List, Optional, Union, Tuple
|
||||
from collections import OrderedDict
|
||||
import os
|
||||
import PIL
|
||||
import numpy as np
|
||||
|
||||
import torch
|
||||
from torchvision import transforms as T
|
||||
|
||||
from safetensors import safe_open
|
||||
from huggingface_hub.utils import validate_hf_hub_args
|
||||
from transformers import CLIPImageProcessor, CLIPTokenizer
|
||||
from diffusers import StableDiffusionXLPipeline
|
||||
from diffusers.pipelines.stable_diffusion_xl import StableDiffusionXLPipelineOutput
|
||||
from diffusers.utils import (
|
||||
_get_model_file,
|
||||
is_transformers_available,
|
||||
logging,
|
||||
)
|
||||
|
||||
from . import PhotoMakerIDEncoder
|
||||
|
||||
PipelineImageInput = Union[
|
||||
PIL.Image.Image,
|
||||
torch.FloatTensor,
|
||||
List[PIL.Image.Image],
|
||||
List[torch.FloatTensor],
|
||||
]
|
||||
|
||||
|
||||
class PhotoMakerStableDiffusionXLPipeline(StableDiffusionXLPipeline):
|
||||
@validate_hf_hub_args
|
||||
def load_photomaker_adapter(
|
||||
self,
|
||||
pretrained_model_name_or_path_or_dict: Union[str, Dict[str, torch.Tensor]],
|
||||
weight_name: str,
|
||||
subfolder: str = '',
|
||||
trigger_word: str = 'img',
|
||||
**kwargs,
|
||||
):
|
||||
"""
|
||||
Parameters:
|
||||
pretrained_model_name_or_path_or_dict (`str` or `os.PathLike` or `dict`):
|
||||
Can be either:
|
||||
|
||||
- A string, the *model id* (for example `google/ddpm-celebahq-256`) of a pretrained model hosted on
|
||||
the Hub.
|
||||
- A path to a *directory* (for example `./my_model_directory`) containing the model weights saved
|
||||
with [`ModelMixin.save_pretrained`].
|
||||
- A [torch state
|
||||
dict](https://pytorch.org/tutorials/beginner/saving_loading_models.html#what-is-a-state-dict).
|
||||
|
||||
weight_name (`str`):
|
||||
The weight name NOT the path to the weight.
|
||||
|
||||
subfolder (`str`, defaults to `""`):
|
||||
The subfolder location of a model file within a larger model repository on the Hub or locally.
|
||||
|
||||
trigger_word (`str`, *optional*, defaults to `"img"`):
|
||||
The trigger word is used to identify the position of class word in the text prompt,
|
||||
and it is recommended not to set it as a common word.
|
||||
This trigger word must be placed after the class word when used, otherwise, it will affect the performance of the personalized generation.
|
||||
"""
|
||||
|
||||
# Load the main state dict first.
|
||||
cache_dir = kwargs.pop("cache_dir", None)
|
||||
force_download = kwargs.pop("force_download", False)
|
||||
resume_download = kwargs.pop("resume_download", False)
|
||||
proxies = kwargs.pop("proxies", None)
|
||||
local_files_only = kwargs.pop("local_files_only", None)
|
||||
token = kwargs.pop("token", None)
|
||||
revision = kwargs.pop("revision", None)
|
||||
|
||||
user_agent = {
|
||||
"file_type": "attn_procs_weights",
|
||||
"framework": "pytorch",
|
||||
}
|
||||
|
||||
if not isinstance(pretrained_model_name_or_path_or_dict, dict):
|
||||
model_file = _get_model_file(
|
||||
pretrained_model_name_or_path_or_dict,
|
||||
weights_name=weight_name,
|
||||
cache_dir=cache_dir,
|
||||
force_download=force_download,
|
||||
resume_download=resume_download,
|
||||
proxies=proxies,
|
||||
local_files_only=local_files_only,
|
||||
token=token,
|
||||
revision=revision,
|
||||
subfolder=subfolder,
|
||||
user_agent=user_agent,
|
||||
)
|
||||
if weight_name.endswith(".safetensors"):
|
||||
state_dict = {"id_encoder": {}, "lora_weights": {}}
|
||||
with safe_open(model_file, framework="pt", device="cpu") as f:
|
||||
for key in f.keys():
|
||||
if key.startswith("id_encoder."):
|
||||
state_dict["id_encoder"][key.replace("id_encoder.", "")] = f.get_tensor(key)
|
||||
elif key.startswith("lora_weights."):
|
||||
state_dict["lora_weights"][key.replace("lora_weights.", "")] = f.get_tensor(key)
|
||||
else:
|
||||
state_dict = torch.load(model_file, map_location="cpu")
|
||||
else:
|
||||
state_dict = pretrained_model_name_or_path_or_dict
|
||||
|
||||
keys = list(state_dict.keys())
|
||||
if keys != ["id_encoder", "lora_weights"]:
|
||||
raise ValueError("Required keys are (`id_encoder` and `lora_weights`) missing from the state dict.")
|
||||
|
||||
self.trigger_word = trigger_word
|
||||
# load finetuned CLIP image encoder and fuse module here if it has not been registered to the pipeline yet
|
||||
print(f"Loading PhotoMaker components [1] id_encoder from [{pretrained_model_name_or_path_or_dict}]...")
|
||||
id_encoder = PhotoMakerIDEncoder()
|
||||
id_encoder.load_state_dict(state_dict["id_encoder"], strict=True)
|
||||
id_encoder = id_encoder.to(self.device, dtype=self.unet.dtype)
|
||||
self.id_encoder = id_encoder
|
||||
self.id_image_processor = CLIPImageProcessor()
|
||||
|
||||
# load lora into models
|
||||
print(f"Loading PhotoMaker components [2] lora_weights from [{pretrained_model_name_or_path_or_dict}]")
|
||||
self.load_lora_weights(state_dict["lora_weights"], adapter_name="photomaker")
|
||||
|
||||
# Add trigger word token
|
||||
if self.tokenizer is not None:
|
||||
self.tokenizer.add_tokens([self.trigger_word], special_tokens=True)
|
||||
|
||||
self.tokenizer_2.add_tokens([self.trigger_word], special_tokens=True)
|
||||
|
||||
|
||||
def encode_prompt_with_trigger_word(
|
||||
self,
|
||||
prompt: str,
|
||||
prompt_2: Optional[str] = None,
|
||||
num_id_images: int = 1,
|
||||
device: Optional[torch.device] = None,
|
||||
prompt_embeds: Optional[torch.FloatTensor] = None,
|
||||
pooled_prompt_embeds: Optional[torch.FloatTensor] = None,
|
||||
class_tokens_mask: Optional[torch.LongTensor] = None,
|
||||
nc_flag: bool = False,
|
||||
):
|
||||
device = device or self._execution_device
|
||||
|
||||
if prompt is not None and isinstance(prompt, str):
|
||||
batch_size = 1
|
||||
elif prompt is not None and isinstance(prompt, list):
|
||||
batch_size = len(prompt)
|
||||
else:
|
||||
batch_size = prompt_embeds.shape[0]
|
||||
|
||||
# Find the token id of the trigger word
|
||||
image_token_id = self.tokenizer_2.convert_tokens_to_ids(self.trigger_word)
|
||||
|
||||
# Define tokenizers and text encoders
|
||||
tokenizers = [self.tokenizer, self.tokenizer_2] if self.tokenizer is not None else [self.tokenizer_2]
|
||||
text_encoders = (
|
||||
[self.text_encoder, self.text_encoder_2] if self.text_encoder is not None else [self.text_encoder_2]
|
||||
)
|
||||
|
||||
if prompt_embeds is None:
|
||||
prompt_2 = prompt_2 or prompt
|
||||
prompt_embeds_list = []
|
||||
prompts = [prompt, prompt_2]
|
||||
for prompt, tokenizer, text_encoder in zip(prompts, tokenizers, text_encoders):
|
||||
input_ids = tokenizer.encode(prompt) # TODO: batch encode
|
||||
clean_index = 0
|
||||
clean_input_ids = []
|
||||
class_token_index = []
|
||||
# Find out the corresponding class word token based on the newly added trigger word token
|
||||
for i, token_id in enumerate(input_ids):
|
||||
if token_id == image_token_id:
|
||||
class_token_index.append(clean_index - 1)
|
||||
else:
|
||||
clean_input_ids.append(token_id)
|
||||
clean_index += 1
|
||||
if nc_flag:
|
||||
return None, None, None
|
||||
if len(class_token_index) > 1:
|
||||
raise ValueError(
|
||||
f"PhotoMaker currently does not support multiple trigger words in a single prompt.\
|
||||
Trigger word: {self.trigger_word}, Prompt: {prompt}."
|
||||
)
|
||||
elif len(class_token_index) == 0 and not nc_flag:
|
||||
raise ValueError(
|
||||
f"PhotoMaker currently does not support multiple trigger words in a single prompt.\
|
||||
Trigger word: {self.trigger_word}, Prompt: {prompt}."
|
||||
)
|
||||
class_token_index = class_token_index[0]
|
||||
|
||||
# Expand the class word token and corresponding mask
|
||||
class_token = clean_input_ids[class_token_index]
|
||||
clean_input_ids = clean_input_ids[:class_token_index] + [class_token] * num_id_images + \
|
||||
clean_input_ids[class_token_index+1:]
|
||||
|
||||
# Truncation or padding
|
||||
max_len = tokenizer.model_max_length
|
||||
if len(clean_input_ids) > max_len:
|
||||
clean_input_ids = clean_input_ids[:max_len]
|
||||
else:
|
||||
clean_input_ids = clean_input_ids + [tokenizer.pad_token_id] * (
|
||||
max_len - len(clean_input_ids)
|
||||
)
|
||||
|
||||
class_tokens_mask = [True if class_token_index <= i < class_token_index+num_id_images else False \
|
||||
for i in range(len(clean_input_ids))]
|
||||
|
||||
clean_input_ids = torch.tensor(clean_input_ids, dtype=torch.long).unsqueeze(0)
|
||||
class_tokens_mask = torch.tensor(class_tokens_mask, dtype=torch.bool).unsqueeze(0)
|
||||
|
||||
prompt_embeds = text_encoder(
|
||||
clean_input_ids.to(device),
|
||||
output_hidden_states=True,
|
||||
)
|
||||
|
||||
# We are only ALWAYS interested in the pooled output of the final text encoder
|
||||
pooled_prompt_embeds = prompt_embeds[0]
|
||||
prompt_embeds = prompt_embeds.hidden_states[-2]
|
||||
prompt_embeds_list.append(prompt_embeds)
|
||||
|
||||
prompt_embeds = torch.concat(prompt_embeds_list, dim=-1)
|
||||
|
||||
prompt_embeds = prompt_embeds.to(dtype=self.text_encoder_2.dtype, device=device)
|
||||
class_tokens_mask = class_tokens_mask.to(device=device) # TODO: ignoring two-prompt case
|
||||
|
||||
return prompt_embeds, pooled_prompt_embeds, class_tokens_mask
|
||||
|
||||
@property
|
||||
def interrupt(self):
|
||||
return self._interrupt
|
||||
|
||||
@torch.no_grad()
|
||||
def __call__(
|
||||
self,
|
||||
prompt: Union[str, List[str]] = None,
|
||||
prompt_2: Optional[Union[str, List[str]]] = None,
|
||||
height: Optional[int] = None,
|
||||
width: Optional[int] = None,
|
||||
num_inference_steps: int = 50,
|
||||
denoising_end: Optional[float] = None,
|
||||
guidance_scale: float = 5.0,
|
||||
negative_prompt: Optional[Union[str, List[str]]] = None,
|
||||
negative_prompt_2: Optional[Union[str, List[str]]] = None,
|
||||
num_images_per_prompt: Optional[int] = 1,
|
||||
eta: float = 0.0,
|
||||
generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
|
||||
latents: Optional[torch.FloatTensor] = None,
|
||||
prompt_embeds: Optional[torch.FloatTensor] = None,
|
||||
negative_prompt_embeds: Optional[torch.FloatTensor] = None,
|
||||
pooled_prompt_embeds: Optional[torch.FloatTensor] = None,
|
||||
negative_pooled_prompt_embeds: Optional[torch.FloatTensor] = None,
|
||||
output_type: Optional[str] = "pil",
|
||||
return_dict: bool = True,
|
||||
cross_attention_kwargs: Optional[Dict[str, Any]] = None,
|
||||
guidance_rescale: float = 0.0,
|
||||
original_size: Optional[Tuple[int, int]] = None,
|
||||
crops_coords_top_left: Tuple[int, int] = (0, 0),
|
||||
target_size: Optional[Tuple[int, int]] = None,
|
||||
callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None,
|
||||
callback_steps: int = 1,
|
||||
callback_on_step_end: Optional[Callable[[int, int, Dict], None]] = None,
|
||||
callback_on_step_end_tensor_inputs: List[str] = ["latents"],
|
||||
# Added parameters (for PhotoMaker)
|
||||
input_id_images: PipelineImageInput = None,
|
||||
start_merge_step: int = 0, # TODO: change to `style_strength_ratio` in the future
|
||||
class_tokens_mask: Optional[torch.LongTensor] = None,
|
||||
prompt_embeds_text_only: Optional[torch.FloatTensor] = None,
|
||||
pooled_prompt_embeds_text_only: Optional[torch.FloatTensor] = None,
|
||||
nc_flag = False,
|
||||
):
|
||||
r"""
|
||||
Function invoked when calling the pipeline for generation.
|
||||
Only the parameters introduced by PhotoMaker are discussed here.
|
||||
For explanations of the previous parameters in StableDiffusionXLPipeline, please refer to https://github.com/huggingface/diffusers/blob/v0.25.0/src/diffusers/pipelines/stable_diffusion_xl/pipeline_stable_diffusion_xl.py
|
||||
|
||||
Args:
|
||||
input_id_images (`PipelineImageInput`, *optional*):
|
||||
Input ID Image to work with PhotoMaker.
|
||||
class_tokens_mask (`torch.LongTensor`, *optional*):
|
||||
Pre-generated class token. When the `prompt_embeds` parameter is provided in advance, it is necessary to prepare the `class_tokens_mask` beforehand for marking out the position of class word.
|
||||
prompt_embeds_text_only (`torch.FloatTensor`, *optional*):
|
||||
Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not
|
||||
provided, text embeddings will be generated from `prompt` input argument.
|
||||
pooled_prompt_embeds_text_only (`torch.FloatTensor`, *optional*):
|
||||
Pre-generated pooled text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting.
|
||||
If not provided, pooled text embeddings will be generated from `prompt` input argument.
|
||||
|
||||
Returns:
|
||||
[`~pipelines.stable_diffusion_xl.StableDiffusionXLPipelineOutput`] or `tuple`:
|
||||
[`~pipelines.stable_diffusion_xl.StableDiffusionXLPipelineOutput`] if `return_dict` is True, otherwise a
|
||||
`tuple`. When returning a tuple, the first element is a list with the generated images.
|
||||
"""
|
||||
# 0. Default height and width to unet
|
||||
height = height or self.unet.config.sample_size * self.vae_scale_factor
|
||||
width = width or self.unet.config.sample_size * self.vae_scale_factor
|
||||
|
||||
original_size = original_size or (height, width)
|
||||
target_size = target_size or (height, width)
|
||||
|
||||
# 1. Check inputs. Raise error if not correct
|
||||
self.check_inputs(
|
||||
prompt,
|
||||
prompt_2,
|
||||
height,
|
||||
width,
|
||||
callback_steps,
|
||||
negative_prompt,
|
||||
negative_prompt_2,
|
||||
prompt_embeds,
|
||||
negative_prompt_embeds,
|
||||
pooled_prompt_embeds,
|
||||
negative_pooled_prompt_embeds,
|
||||
callback_on_step_end_tensor_inputs,
|
||||
)
|
||||
|
||||
self._interrupt = False
|
||||
|
||||
#
|
||||
if prompt_embeds is not None and class_tokens_mask is None:
|
||||
raise ValueError(
|
||||
"If `prompt_embeds` are provided, `class_tokens_mask` also have to be passed. Make sure to generate `class_tokens_mask` from the same tokenizer that was used to generate `prompt_embeds`."
|
||||
)
|
||||
# check the input id images
|
||||
if input_id_images is None:
|
||||
raise ValueError(
|
||||
"Provide `input_id_images`. Cannot leave `input_id_images` undefined for PhotoMaker pipeline."
|
||||
)
|
||||
if not isinstance(input_id_images, list):
|
||||
input_id_images = [input_id_images]
|
||||
|
||||
# 2. Define call parameters
|
||||
if prompt is not None and isinstance(prompt, str):
|
||||
batch_size = 1
|
||||
prompt = [prompt]
|
||||
elif prompt is not None and isinstance(prompt, list):
|
||||
batch_size = len(prompt)
|
||||
else:
|
||||
batch_size = prompt_embeds.shape[0]
|
||||
|
||||
device = self._execution_device
|
||||
|
||||
# here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
|
||||
# of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
|
||||
# corresponds to doing no classifier free guidance.
|
||||
do_classifier_free_guidance = guidance_scale >= 1.0
|
||||
|
||||
assert do_classifier_free_guidance
|
||||
|
||||
# 3. Encode input prompt
|
||||
num_id_images = len(input_id_images)
|
||||
if isinstance(prompt, list):
|
||||
prompt_arr = prompt
|
||||
negative_prompt_embeds_arr = []
|
||||
prompt_embeds_text_only_arr = []
|
||||
prompt_embeds_arr = []
|
||||
latents_arr = []
|
||||
add_time_ids_arr = []
|
||||
negative_pooled_prompt_embeds_arr = []
|
||||
pooled_prompt_embeds_text_only_arr = []
|
||||
pooled_prompt_embeds_arr = []
|
||||
for prompt in prompt_arr:
|
||||
(
|
||||
prompt_embeds,
|
||||
pooled_prompt_embeds,
|
||||
class_tokens_mask,
|
||||
) = self.encode_prompt_with_trigger_word(
|
||||
prompt=prompt,
|
||||
prompt_2=prompt_2,
|
||||
device=device,
|
||||
num_id_images=num_id_images,
|
||||
prompt_embeds=prompt_embeds,
|
||||
pooled_prompt_embeds=pooled_prompt_embeds,
|
||||
class_tokens_mask=class_tokens_mask,
|
||||
nc_flag = nc_flag,
|
||||
)
|
||||
|
||||
# 4. Encode input prompt without the trigger word for delayed conditioning
|
||||
# encode, remove trigger word token, then decode
|
||||
tokens_text_only = self.tokenizer.encode(prompt, add_special_tokens=False)
|
||||
trigger_word_token = self.tokenizer.convert_tokens_to_ids(self.trigger_word)
|
||||
if not nc_flag:
|
||||
tokens_text_only.remove(trigger_word_token)
|
||||
prompt_text_only = self.tokenizer.decode(tokens_text_only, add_special_tokens=False)
|
||||
print(prompt_text_only)
|
||||
(
|
||||
prompt_embeds_text_only,
|
||||
negative_prompt_embeds,
|
||||
pooled_prompt_embeds_text_only, # TODO: replace the pooled_prompt_embeds with text only prompt
|
||||
negative_pooled_prompt_embeds,
|
||||
) = self.encode_prompt(
|
||||
prompt=prompt_text_only,
|
||||
prompt_2=prompt_2,
|
||||
device=device,
|
||||
num_images_per_prompt=num_images_per_prompt,
|
||||
do_classifier_free_guidance=True,
|
||||
negative_prompt=negative_prompt,
|
||||
negative_prompt_2=negative_prompt_2,
|
||||
prompt_embeds=prompt_embeds_text_only,
|
||||
negative_prompt_embeds=negative_prompt_embeds,
|
||||
pooled_prompt_embeds=pooled_prompt_embeds_text_only,
|
||||
negative_pooled_prompt_embeds=negative_pooled_prompt_embeds,
|
||||
)
|
||||
|
||||
# 5. Prepare the input ID images
|
||||
dtype = next(self.id_encoder.parameters()).dtype
|
||||
if not isinstance(input_id_images[0], torch.Tensor):
|
||||
id_pixel_values = self.id_image_processor(input_id_images, return_tensors="pt").pixel_values
|
||||
|
||||
id_pixel_values = id_pixel_values.unsqueeze(0).to(device=device, dtype=dtype) # TODO: multiple prompts
|
||||
|
||||
# duplicate text embeddings for each generation per prompt, using mps friendly method
|
||||
if not nc_flag:
|
||||
# 6. Get the update text embedding with the stacked ID embedding
|
||||
prompt_embeds = self.id_encoder(id_pixel_values, prompt_embeds, class_tokens_mask)
|
||||
|
||||
bs_embed, seq_len, _ = prompt_embeds.shape
|
||||
prompt_embeds = prompt_embeds.repeat(1, num_images_per_prompt, 1)
|
||||
prompt_embeds = prompt_embeds.view(bs_embed * num_images_per_prompt, seq_len, -1)
|
||||
pooled_prompt_embeds = pooled_prompt_embeds.repeat(1, num_images_per_prompt).view(
|
||||
bs_embed * num_images_per_prompt, -1
|
||||
)
|
||||
pooled_prompt_embeds_arr.append(pooled_prompt_embeds)
|
||||
pooled_prompt_embeds = None
|
||||
|
||||
negative_prompt_embeds_arr.append(negative_prompt_embeds)
|
||||
negative_prompt_embeds = None
|
||||
negative_pooled_prompt_embeds_arr.append(negative_pooled_prompt_embeds)
|
||||
negative_pooled_prompt_embeds = None
|
||||
prompt_embeds_text_only_arr.append(prompt_embeds_text_only)
|
||||
prompt_embeds_text_only = None
|
||||
prompt_embeds_arr.append(prompt_embeds)
|
||||
prompt_embeds = None
|
||||
pooled_prompt_embeds_text_only_arr.append(pooled_prompt_embeds_text_only)
|
||||
pooled_prompt_embeds_text_only = None
|
||||
# 7. Prepare timesteps
|
||||
self.scheduler.set_timesteps(num_inference_steps, device=device)
|
||||
timesteps = self.scheduler.timesteps
|
||||
|
||||
negative_prompt_embeds = torch.cat(negative_prompt_embeds_arr ,dim =0)
|
||||
print(negative_prompt_embeds.shape)
|
||||
if not nc_flag:
|
||||
prompt_embeds = torch.cat(prompt_embeds_arr ,dim = 0)
|
||||
print(prompt_embeds.shape)
|
||||
pooled_prompt_embeds = torch.cat(pooled_prompt_embeds_arr,dim = 0)
|
||||
print(pooled_prompt_embeds.shape)
|
||||
|
||||
prompt_embeds_text_only = torch.cat(prompt_embeds_text_only_arr ,dim = 0)
|
||||
print(prompt_embeds_text_only.shape)
|
||||
pooled_prompt_embeds_text_only = torch.cat(pooled_prompt_embeds_text_only_arr ,dim = 0)
|
||||
print(pooled_prompt_embeds_text_only.shape)
|
||||
|
||||
negative_pooled_prompt_embeds = torch.cat(negative_pooled_prompt_embeds_arr ,dim = 0)
|
||||
print(negative_pooled_prompt_embeds.shape)
|
||||
# 8. Prepare latent variables
|
||||
num_channels_latents = self.unet.config.in_channels
|
||||
latents = self.prepare_latents(
|
||||
batch_size * num_images_per_prompt,
|
||||
num_channels_latents,
|
||||
height,
|
||||
width,
|
||||
prompt_embeds.dtype if not nc_flag else prompt_embeds_text_only.dtype,
|
||||
device,
|
||||
generator,
|
||||
latents,
|
||||
)
|
||||
|
||||
# 9. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline
|
||||
extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta)
|
||||
|
||||
# 10. Prepare added time ids & embeddings
|
||||
if self.text_encoder_2 is None:
|
||||
text_encoder_projection_dim = int(pooled_prompt_embeds.shape[-1])
|
||||
else:
|
||||
text_encoder_projection_dim = self.text_encoder_2.config.projection_dim
|
||||
|
||||
add_time_ids = self._get_add_time_ids(
|
||||
original_size,
|
||||
crops_coords_top_left,
|
||||
target_size,
|
||||
dtype=prompt_embeds.dtype if not nc_flag else prompt_embeds_text_only.dtype,
|
||||
text_encoder_projection_dim=text_encoder_projection_dim,
|
||||
)
|
||||
add_time_ids = torch.cat([add_time_ids, add_time_ids], dim=0)
|
||||
add_time_ids = add_time_ids.to(device).repeat(batch_size * num_images_per_prompt, 1)
|
||||
|
||||
|
||||
print(latents.shape)
|
||||
print(add_time_ids.shape)
|
||||
|
||||
# 11. Denoising loop
|
||||
num_warmup_steps = len(timesteps) - num_inference_steps * self.scheduler.order
|
||||
with self.progress_bar(total=num_inference_steps) as progress_bar:
|
||||
for i, t in enumerate(timesteps):
|
||||
if self.interrupt:
|
||||
continue
|
||||
|
||||
latent_model_input = (
|
||||
torch.cat([latents] * 2) if do_classifier_free_guidance else latents
|
||||
)
|
||||
latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)
|
||||
|
||||
if i <= start_merge_step or nc_flag:
|
||||
current_prompt_embeds = torch.cat(
|
||||
[negative_prompt_embeds, prompt_embeds_text_only], dim=0
|
||||
)
|
||||
add_text_embeds = torch.cat([negative_pooled_prompt_embeds, pooled_prompt_embeds_text_only], dim=0)
|
||||
else:
|
||||
current_prompt_embeds = torch.cat(
|
||||
[negative_prompt_embeds, prompt_embeds], dim=0
|
||||
)
|
||||
add_text_embeds = torch.cat([negative_pooled_prompt_embeds, pooled_prompt_embeds], dim=0)
|
||||
# predict the noise residual
|
||||
added_cond_kwargs = {"text_embeds": add_text_embeds, "time_ids": add_time_ids}
|
||||
# print(latent_model_input.shape)
|
||||
# print(t)
|
||||
# print(current_prompt_embeds.shape)
|
||||
# print(add_text_embeds.shape)
|
||||
# print(add_time_ids.shape)
|
||||
#zeros_matrix =
|
||||
#global_mask1024 = torch.cat([torch.randn(1, 1024, 1, 1, device=device) for random_number])
|
||||
#global_mask4096 =
|
||||
noise_pred = self.unet(
|
||||
latent_model_input,
|
||||
t,
|
||||
encoder_hidden_states=current_prompt_embeds,
|
||||
cross_attention_kwargs=cross_attention_kwargs,
|
||||
added_cond_kwargs=added_cond_kwargs,
|
||||
return_dict=False,
|
||||
)[0]
|
||||
# print(noise_pred.shape)
|
||||
# perform guidance
|
||||
if do_classifier_free_guidance:
|
||||
noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
|
||||
noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
|
||||
|
||||
if do_classifier_free_guidance and guidance_rescale > 0.0:
|
||||
# Based on 3.4. in https://arxiv.org/pdf/2305.08891.pdf
|
||||
noise_pred = rescale_noise_cfg(noise_pred, noise_pred_text, guidance_rescale=guidance_rescale)
|
||||
|
||||
# compute the previous noisy sample x_t -> x_t-1
|
||||
latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs, return_dict=False)[0]
|
||||
|
||||
if callback_on_step_end is not None:
|
||||
callback_kwargs = {}
|
||||
for k in callback_on_step_end_tensor_inputs:
|
||||
callback_kwargs[k] = locals()[k]
|
||||
|
||||
ck_outputs = callback_on_step_end(self, i, t, callback_kwargs)
|
||||
|
||||
latents = callback_outputs.pop("latents", latents)
|
||||
prompt_embeds = callback_outputs.pop("prompt_embeds", prompt_embeds)
|
||||
negative_prompt_embeds = callback_outputs.pop("negative_prompt_embeds", negative_prompt_embeds)
|
||||
add_text_embeds = callback_outputs.pop("add_text_embeds", add_text_embeds)
|
||||
# negative_pooled_prompt_embeds = callback_outputs.pop(
|
||||
# "negative_pooled_prompt_embeds", negative_pooled_prompt_embeds
|
||||
# )
|
||||
# add_time_ids = callback_outputs.pop("add_time_ids", add_time_ids)
|
||||
# negative_add_time_ids = callback_outputs.pop("negative_add_time_ids", negative_add_time_ids)
|
||||
|
||||
# call the callback, if provided
|
||||
if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):
|
||||
progress_bar.update()
|
||||
if callback is not None and i % callback_steps == 0:
|
||||
step_idx = i // getattr(self.scheduler, "order", 1)
|
||||
callback(step_idx, t, latents)
|
||||
|
||||
# make sure the VAE is in float32 mode, as it overflows in float16
|
||||
if self.vae.dtype == torch.float16 and self.vae.config.force_upcast:
|
||||
self.upcast_vae()
|
||||
latents = latents.to(next(iter(self.vae.post_quant_conv.parameters())).dtype)
|
||||
|
||||
if not output_type == "latent":
|
||||
image = self.vae.decode(latents / self.vae.config.scaling_factor, return_dict=False)[0]
|
||||
else:
|
||||
image = latents
|
||||
return StableDiffusionXLPipelineOutput(images=image)
|
||||
|
||||
# apply watermark if available
|
||||
# if self.watermark is not None:
|
||||
# image = self.watermark.apply_watermark(image)
|
||||
|
||||
image = self.image_processor.postprocess(image, output_type=output_type)
|
||||
|
||||
# Offload all models
|
||||
self.maybe_free_model_hooks()
|
||||
|
||||
if not return_dict:
|
||||
return (image,)
|
||||
|
||||
return StableDiffusionXLPipelineOutput(images=image)
|
||||
@@ -0,0 +1,49 @@
|
||||
style_list = [
|
||||
{
|
||||
"name": "(No style)",
|
||||
"prompt": "{prompt}",
|
||||
"negative_prompt": "",
|
||||
},
|
||||
{
|
||||
"name": "Japanese Anime",
|
||||
"prompt": "anime artwork illustrating {prompt}. created by japanese anime studio. highly emotional. best quality, high resolution, (Anime Style, Manga Style:1.3), Low detail, sketch, concept art, line art, webtoon, manhua, hand drawn, defined lines, simple shades, minimalistic, High contrast, Linear compositions, Scalable artwork, Digital art, High Contrast Shadows",
|
||||
"negative_prompt": "lowres, bad anatomy, bad hands, text, error, missing fingers, extra digit, fewer digits, cropped, worst quality, low quality, normal quality, jpeg artifacts, signature, watermark, username, blurry",
|
||||
},
|
||||
{
|
||||
"name": "Digital/Oil Painting",
|
||||
"prompt": "{prompt} . (Extremely Detailed Oil Painting:1.2), glow effects, godrays, Hand drawn, render, 8k, octane render, cinema 4d, blender, dark, atmospheric 4k ultra detailed, cinematic sensual, Sharp focus, humorous illustration, big depth of field",
|
||||
"negative_prompt": "anime, cartoon, graphic, text, painting, crayon, graphite, abstract, glitch, deformed, mutated, ugly, disfigured, lowres, bad anatomy, bad hands, text, error, missing fingers, extra digit, fewer digits, cropped, worst quality, low quality, normal quality, jpeg artifacts, signature, watermark, username, blurry",
|
||||
},
|
||||
{
|
||||
"name": "Pixar/Disney Character",
|
||||
"prompt": "Create a Disney Pixar 3D style illustration on {prompt} . The scene is vibrant, motivational, filled with vivid colors and a sense of wonder.",
|
||||
"negative_prompt": "lowres, bad anatomy, bad hands, text, bad eyes, bad arms, bad legs, error, missing fingers, extra digit, fewer digits, cropped, worst quality, low quality, normal quality, jpeg artifacts, signature, watermark, blurry, grayscale, noisy, sloppy, messy, grainy, highly detailed, ultra textured, photo",
|
||||
},
|
||||
{
|
||||
"name": "Photographic",
|
||||
"prompt": "cinematic photo {prompt} . Hyperrealistic, Hyperdetailed, detailed skin, matte skin, soft lighting, realistic, best quality, ultra realistic, 8k, golden ratio, Intricate, High Detail, film photography, soft focus",
|
||||
"negative_prompt": "drawing, painting, crayon, sketch, graphite, impressionist, noisy, blurry, soft, deformed, ugly, lowres, bad anatomy, bad hands, text, error, missing fingers, extra digit, fewer digits, cropped, worst quality, low quality, normal quality, jpeg artifacts, signature, watermark, username, blurry",
|
||||
},
|
||||
{
|
||||
"name": "Comic book",
|
||||
"prompt": "comic {prompt} . graphic illustration, comic art, graphic novel art, vibrant, highly detailed",
|
||||
"negative_prompt": "photograph, deformed, glitch, noisy, realistic, stock photo, lowres, bad anatomy, bad hands, text, error, missing fingers, extra digit, fewer digits, cropped, worst quality, low quality, normal quality, jpeg artifacts, signature, watermark, username, blurry",
|
||||
},
|
||||
{
|
||||
"name": "Line art",
|
||||
"prompt": "line art drawing {prompt} . professional, sleek, modern, minimalist, graphic, line art, vector graphics",
|
||||
"negative_prompt": "anime, photorealistic, 35mm film, deformed, glitch, blurry, noisy, off-center, deformed, cross-eyed, closed eyes, bad anatomy, ugly, disfigured, mutated, realism, realistic, impressionism, expressionism, oil, acrylic, lowres, bad anatomy, bad hands, text, error, missing fingers, extra digit, fewer digits, cropped, worst quality, low quality, normal quality, jpeg artifacts, signature, watermark, username, blurry",
|
||||
},
|
||||
{
|
||||
"name": "Black and White Film Noir",
|
||||
"prompt": "{prompt} . (b&w, Monochromatic, Film Photography:1.3), film noir, analog style, soft lighting, subsurface scattering, realistic, heavy shadow, masterpiece, best quality, ultra realistic, 8k",
|
||||
"negative_prompt": "anime, photorealistic, 35mm film, deformed, glitch, blurry, noisy, off-center, deformed, cross-eyed, closed eyes, bad anatomy, ugly, disfigured, mutated, realism, realistic, impressionism, expressionism, oil, acrylic, lowres, bad anatomy, bad hands, text, error, missing fingers, extra digit, fewer digits, cropped, worst quality, low quality, normal quality, jpeg artifacts, signature, watermark, username, blurry",
|
||||
},
|
||||
{
|
||||
"name": "Isometric Rooms",
|
||||
"prompt": "Tiny cute isometric {prompt} . in a cutaway box, soft smooth lighting, soft colors, 100mm lens, 3d blender render",
|
||||
"negative_prompt": "anime, photorealistic, 35mm film, deformed, glitch, blurry, noisy, off-center, deformed, cross-eyed, closed eyes, bad anatomy, ugly, disfigured, mutated, realism, realistic, impressionism, expressionism, oil, acrylic, lowres, bad anatomy, bad hands, text, error, missing fingers, extra digit, fewer digits, cropped, worst quality, low quality, normal quality, jpeg artifacts, signature, watermark, username, blurry",
|
||||
},
|
||||
]
|
||||
|
||||
styles = {k["name"]: (k["prompt"], k["negative_prompt"]) for k in style_list}
|
||||
+432
@@ -0,0 +1,432 @@
|
||||
from email.mime import image
|
||||
import torch
|
||||
import base64
|
||||
import gradio as gr
|
||||
import numpy as np
|
||||
from PIL import Image,ImageOps,ImageDraw, ImageFont
|
||||
from io import BytesIO
|
||||
import random
|
||||
MAX_COLORS = 12
|
||||
import os
|
||||
dir_path = os.path.dirname(os.path.abspath(__file__))
|
||||
path_dir = os.path.dirname(dir_path)
|
||||
file_path = os.path.dirname(path_dir)
|
||||
#print(dir_path,file_path)
|
||||
def get_random_bool():
|
||||
return random.choice([True, False])
|
||||
|
||||
def add_white_border(input_image, border_width=10):
|
||||
"""
|
||||
为PIL图像添加指定宽度的白色边框。
|
||||
|
||||
:param input_image: PIL图像对象
|
||||
:param border_width: 边框宽度（单位：像素）
|
||||
:return: 带有白色边框的PIL图像对象
|
||||
"""
|
||||
border_color = 'white' # 白色边框
|
||||
# 添加边框
|
||||
img_with_border = ImageOps.expand(input_image, border=border_width, fill=border_color)
|
||||
return img_with_border
|
||||
|
||||
def process_mulline_text(draw, text, font, max_width):
|
||||
"""
|
||||
Draw the text on an image with word wrapping.
|
||||
"""
|
||||
lines = [] # Store the lines of text here
|
||||
words = text.split()
|
||||
|
||||
# Start building lines of text, and wrap when necessary
|
||||
current_line = ""
|
||||
for word in words:
|
||||
test_line = f"{current_line} {word}".strip()
|
||||
# Check the width of the line with this word added
|
||||
bbox = draw.textbbox((0, 0), test_line, font=font)
|
||||
text_left, text_top, text_right, text_bottom = bbox
|
||||
|
||||
width, _ = (text_right - text_left, text_bottom - text_top)
|
||||
|
||||
if width <= max_width:
|
||||
# If it fits, add this word to the current line
|
||||
current_line = test_line
|
||||
else:
|
||||
# If not, store the line and start a new one
|
||||
lines.append(current_line)
|
||||
current_line = word
|
||||
# Add the last line
|
||||
lines.append(current_line)
|
||||
return lines
|
||||
|
||||
|
||||
|
||||
def add_caption(image, text, position = "bottom-mid", font = None, text_color= 'black', bg_color = (255, 255, 255) , bg_opacity = 200):
|
||||
if text == "":
|
||||
return image
|
||||
image = image.convert("RGBA")
|
||||
draw = ImageDraw.Draw(image)
|
||||
width, height = image.size
|
||||
lines = process_mulline_text(draw,text,font,width)
|
||||
text_positions = []
|
||||
maxwidth = 0
|
||||
for ind, line in enumerate(lines[::-1]):
|
||||
bbox = draw.textbbox((0, 0), line, font=font)
|
||||
text_left, text_top, text_right, text_bottom = bbox
|
||||
text_width, text_height = (text_right - text_left, text_bottom - text_top)
|
||||
if position == 'bottom-right':
|
||||
text_position = (width - text_width - 10, height - (text_height + 20))
|
||||
elif position == 'bottom-left':
|
||||
text_position = (10, height - (text_height + 20))
|
||||
elif position == 'bottom-mid':
|
||||
text_position = ((width - text_width) // 2, height - (text_height + 20) ) # 居中文本
|
||||
height = text_position[1]
|
||||
maxwidth = max(maxwidth,text_width)
|
||||
text_positions.append(text_position)
|
||||
rectpos = (width - maxwidth) // 2
|
||||
rectangle_position = [rectpos - 5, text_positions[-1][1] - 5, rectpos + maxwidth + 5, text_positions[0][1] + text_height + 5]
|
||||
image_with_transparency = Image.new('RGBA', image.size)
|
||||
draw_with_transparency = ImageDraw.Draw(image_with_transparency)
|
||||
draw_with_transparency.rectangle(rectangle_position, fill=bg_color + (bg_opacity,))
|
||||
|
||||
image.paste(Image.alpha_composite(image.convert('RGBA'), image_with_transparency))
|
||||
print(ind,text_position)
|
||||
draw = ImageDraw.Draw(image)
|
||||
for ind, line in enumerate(lines[::-1]):
|
||||
text_position = text_positions[ind]
|
||||
draw.text(text_position, line, fill=text_color, font=font)
|
||||
|
||||
return image.convert('RGB')
|
||||
|
||||
def get_comic(images,types = "4panel",captions = [],font = None,pad_image = None):
|
||||
font_check_path = os.path.join(path_dir,"images","pad_images.png")
|
||||
if pad_image == None:
|
||||
pad_image = Image.open(font_check_path)
|
||||
|
||||
if types == "No typesetting (default)":
|
||||
return images
|
||||
elif types == "Four Pannel":
|
||||
return get_comic_4panel(images,captions,font,pad_image)
|
||||
else: # "Classic Comic Style"
|
||||
return get_comic_classical(images,captions,font,pad_image)
|
||||
|
||||
def get_caption_group(images_groups,captions = []):
|
||||
caption_groups = []
|
||||
for i in range(len(images_groups)):
|
||||
length = len(images_groups[i])
|
||||
caption_groups.append(captions[:length])
|
||||
captions = captions[length:]
|
||||
if len(caption_groups[-1]) < len(images_groups[-1]):
|
||||
caption_groups[-1] = caption_groups[-1] + [""] * (len(images_groups[-1]) - len(caption_groups[-1]))
|
||||
return caption_groups
|
||||
|
||||
def get_comic_classical(images,captions = None,font = None,pad_image = None):
|
||||
if pad_image == None:
|
||||
raise ValueError("pad_image is None")
|
||||
images = [add_white_border(image) for image in images]
|
||||
pad_image = pad_image.resize(images[0].size, Image.LANCZOS)
|
||||
images_groups = distribute_images2(images,pad_image)
|
||||
print(images_groups)
|
||||
if captions != None:
|
||||
captions_groups = get_caption_group(images_groups,captions)
|
||||
# print(images_groups)
|
||||
row_images = []
|
||||
for ind, img_group in enumerate(images_groups):
|
||||
row_images.append(get_row_image2(img_group ,captions= captions_groups[ind] if captions != None else None,font = font))
|
||||
|
||||
return [combine_images_vertically_with_resize(row_images)]
|
||||
|
||||
|
||||
|
||||
def get_comic_4panel(images,captions = [],font = None,pad_image = None):
|
||||
if pad_image == None:
|
||||
raise ValueError("pad_image is None")
|
||||
pad_image = pad_image.resize(images[0].size, Image.LANCZOS)
|
||||
images = [add_white_border(image) for image in images]
|
||||
assert len(captions) == len(images)
|
||||
for i,caption in enumerate(captions):
|
||||
images[i] = add_caption(images[i],caption,font = font)
|
||||
images_nums = len(images)
|
||||
pad_nums = int((4 - images_nums % 4) % 4)
|
||||
images = images + [pad_image for _ in range(pad_nums)]
|
||||
comics = []
|
||||
assert len(images)%4 == 0
|
||||
for i in range(len(images)//4):
|
||||
comics.append(combine_images_vertically_with_resize([combine_images_horizontally(images[i*4:i*4+2]), combine_images_horizontally(images[i*4+2:i*4+4])]))
|
||||
|
||||
return comics
|
||||
|
||||
def get_row_image(images):
|
||||
row_image_arr = []
|
||||
if len(images)>3:
|
||||
stack_img_nums = (len(images) - 2)//2
|
||||
else:
|
||||
stack_img_nums = 0
|
||||
while(len(images)>0):
|
||||
if stack_img_nums <=0:
|
||||
row_image_arr.append(images[0])
|
||||
images = images[1:]
|
||||
elif len(images)>stack_img_nums*2:
|
||||
if get_random_bool():
|
||||
row_image_arr.append(concat_images_vertically_and_scale(images[:2]))
|
||||
images = images[2:]
|
||||
stack_img_nums -=1
|
||||
else:
|
||||
row_image_arr.append(images[0])
|
||||
images = images[1:]
|
||||
else:
|
||||
row_image_arr.append(concat_images_vertically_and_scale(images[:2]))
|
||||
images = images[2:]
|
||||
stack_img_nums-=1
|
||||
return combine_images_horizontally(row_image_arr)
|
||||
|
||||
def get_row_image2(images,captions = None, font = None):
|
||||
row_image_arr = []
|
||||
if len(images)== 6:
|
||||
sequence_list = [1,1,2,2]
|
||||
elif len(images)== 4:
|
||||
sequence_list = [1,1,2]
|
||||
else:
|
||||
raise ValueError("images nums is not 4 or 6 found",len(images))
|
||||
random.shuffle(sequence_list)
|
||||
index = 0
|
||||
for length in sequence_list:
|
||||
if length == 1:
|
||||
if captions != None:
|
||||
images_tmp = add_caption(images[0],text = captions[index],font= font)
|
||||
else:
|
||||
images_tmp = images[0]
|
||||
row_image_arr.append( images_tmp)
|
||||
images = images[1:]
|
||||
index +=1
|
||||
elif length == 2:
|
||||
row_image_arr.append(concat_images_vertically_and_scale(images[:2]))
|
||||
images = images[2:]
|
||||
index +=2
|
||||
|
||||
return combine_images_horizontally(row_image_arr)
|
||||
|
||||
|
||||
|
||||
def concat_images_vertically_and_scale(images,scale_factor=2):
|
||||
# 加载所有图像
|
||||
# 确保所有图像的宽度一致
|
||||
widths = [img.width for img in images]
|
||||
if not all(width == widths[0] for width in widths):
|
||||
raise ValueError('All images must have the same width.')
|
||||
|
||||
# 计算总高度
|
||||
total_height = sum(img.height for img in images)
|
||||
|
||||
# 创建新的图像，宽度与原图相同，高度为所有图像高度之和
|
||||
max_width = max(widths)
|
||||
concatenated_image = Image.new('RGB', (max_width, total_height))
|
||||
|
||||
# 竖直拼接图像
|
||||
current_height = 0
|
||||
for img in images:
|
||||
concatenated_image.paste(img, (0, current_height))
|
||||
current_height += img.height
|
||||
|
||||
# 缩放图像为1/n高度
|
||||
new_height = concatenated_image.height // scale_factor
|
||||
new_width = concatenated_image.width // scale_factor
|
||||
resized_image = concatenated_image.resize((new_width, new_height), Image.LANCZOS)
|
||||
|
||||
return resized_image
|
||||
|
||||
|
||||
def combine_images_horizontally(images):
|
||||
# 读取所有图片并存入列表
|
||||
|
||||
# 获取每幅图像的宽度和高度
|
||||
widths, heights = zip(*(i.size for i in images))
|
||||
|
||||
# 计算总宽度和最大高度
|
||||
total_width = sum(widths)
|
||||
max_height = max(heights)
|
||||
|
||||
# 创建新的空白图片，用于拼接
|
||||
new_im = Image.new('RGB', (total_width, max_height))
|
||||
|
||||
# 将图片横向拼接
|
||||
x_offset = 0
|
||||
for im in images:
|
||||
new_im.paste(im, (x_offset, 0))
|
||||
x_offset += im.width
|
||||
|
||||
return new_im
|
||||
|
||||
def combine_images_vertically_with_resize(images):
|
||||
|
||||
# 获取所有图片的宽度和高度
|
||||
widths, heights = zip(*(i.size for i in images))
|
||||
|
||||
# 确定新图片的宽度，即所有图片中最小的宽度
|
||||
min_width = min(widths)
|
||||
|
||||
# 调整图片尺寸以保持宽度一致，长宽比不变
|
||||
resized_images = []
|
||||
for img in images:
|
||||
# 计算新高度保持图片长宽比
|
||||
new_height = int(min_width * img.height / img.width)
|
||||
# 调整图片大小
|
||||
resized_img = img.resize((min_width, new_height), Image.LANCZOS)
|
||||
resized_images.append(resized_img)
|
||||
|
||||
# 计算所有调整尺寸后图片的总高度
|
||||
total_height = sum(img.height for img in resized_images)
|
||||
|
||||
# 创建一个足够宽和高的新图片对象
|
||||
new_im = Image.new('RGB', (min_width, total_height))
|
||||
|
||||
# 竖直拼接图片
|
||||
y_offset = 0
|
||||
for im in resized_images:
|
||||
new_im.paste(im, (0, y_offset))
|
||||
y_offset += im.height
|
||||
|
||||
return new_im
|
||||
|
||||
def distribute_images2(images, pad_image):
|
||||
groups = []
|
||||
remaining = len(images)
|
||||
if len(images) <= 8:
|
||||
group_sizes = [4]
|
||||
else:
|
||||
group_sizes = [4, 6]
|
||||
|
||||
size_index = 0
|
||||
while remaining > 0:
|
||||
size = group_sizes[size_index%len(group_sizes)]
|
||||
if remaining < size and remaining < min(group_sizes):
|
||||
size = min(group_sizes)
|
||||
if remaining > size:
|
||||
new_group = images[-remaining: -remaining + size]
|
||||
else:
|
||||
new_group = images[-remaining:]
|
||||
groups.append(new_group)
|
||||
size_index += 1
|
||||
remaining -= size
|
||||
print(remaining,groups)
|
||||
groups[-1] = groups[-1] + [pad_image for _ in range(-remaining)]
|
||||
|
||||
return groups
|
||||
|
||||
|
||||
def distribute_images(images, group_sizes=(4, 3, 2)):
|
||||
groups = []
|
||||
remaining = len(images)
|
||||
|
||||
while remaining > 0:
|
||||
# 优先分配最大组（4张图片），再考虑3张，最后处理2张
|
||||
for size in sorted(group_sizes, reverse=True):
|
||||
# 如果剩下的图片数量大于等于当前组大小，或者为图片总数时（也就是第一次迭代）
|
||||
# 开始创建新组
|
||||
if remaining >= size or remaining == len(images):
|
||||
if remaining > size:
|
||||
new_group = images[-remaining: -remaining + size]
|
||||
else:
|
||||
new_group = images[-remaining:]
|
||||
groups.append(new_group)
|
||||
remaining -= size
|
||||
break
|
||||
# 如果剩下的图片少于最小的组大小（2张）并且已经有组了，就把剩下的图片加到最后一个组
|
||||
elif remaining < min(group_sizes) and groups:
|
||||
groups[-1].extend(images[-remaining:])
|
||||
remaining = 0
|
||||
|
||||
return groups
|
||||
|
||||
def create_binary_matrix(img_arr, target_color):
|
||||
mask = np.all(img_arr == target_color, axis=-1)
|
||||
binary_matrix = mask.astype(int)
|
||||
return binary_matrix
|
||||
|
||||
def preprocess_mask(mask_, h, w, device):
|
||||
mask = np.array(mask_)
|
||||
mask = mask.astype(np.float32)
|
||||
mask = mask[None, None]
|
||||
mask[mask < 0.5] = 0
|
||||
mask[mask >= 0.5] = 1
|
||||
mask = torch.from_numpy(mask).to(device)
|
||||
mask = torch.nn.functional.interpolate(mask, size=(h, w), mode='nearest')
|
||||
return mask
|
||||
|
||||
def process_sketch(canvas_data):
|
||||
binary_matrixes = []
|
||||
base64_img = canvas_data['image']
|
||||
image_data = base64.b64decode(base64_img.split(',')[1])
|
||||
image = Image.open(BytesIO(image_data)).convert("RGB")
|
||||
im2arr = np.array(image)
|
||||
colors = [tuple(map(int, rgb[4:-1].split(','))) for rgb in canvas_data['colors']]
|
||||
colors_fixed = []
|
||||
|
||||
r, g, b = 255, 255, 255
|
||||
binary_matrix = create_binary_matrix(im2arr, (r,g,b))
|
||||
binary_matrixes.append(binary_matrix)
|
||||
binary_matrix_ = np.repeat(np.expand_dims(binary_matrix, axis=(-1)), 3, axis=(-1))
|
||||
colored_map = binary_matrix_*(r,g,b) + (1-binary_matrix_)*(50,50,50)
|
||||
colors_fixed.append(gr.update(value=colored_map.astype(np.uint8)))
|
||||
|
||||
for color in colors:
|
||||
r, g, b = color
|
||||
if any(c != 255 for c in (r, g, b)):
|
||||
binary_matrix = create_binary_matrix(im2arr, (r,g,b))
|
||||
binary_matrixes.append(binary_matrix)
|
||||
binary_matrix_ = np.repeat(np.expand_dims(binary_matrix, axis=(-1)), 3, axis=(-1))
|
||||
colored_map = binary_matrix_*(r,g,b) + (1-binary_matrix_)*(50,50,50)
|
||||
colors_fixed.append(gr.update(value=colored_map.astype(np.uint8)))
|
||||
|
||||
visibilities = []
|
||||
colors = []
|
||||
for n in range(MAX_COLORS):
|
||||
visibilities.append(gr.update(visible=False))
|
||||
colors.append(gr.update())
|
||||
for n in range(len(colors_fixed)):
|
||||
visibilities[n] = gr.update(visible=True)
|
||||
colors[n] = colors_fixed[n]
|
||||
|
||||
return [gr.update(visible=True), binary_matrixes, *visibilities, *colors]
|
||||
|
||||
def process_prompts(binary_matrixes, *seg_prompts):
|
||||
return [gr.update(visible=True), gr.update(value=' , '.join(seg_prompts[:len(binary_matrixes)]))]
|
||||
|
||||
def process_example(layout_path, all_prompts, seed_):
|
||||
|
||||
all_prompts = all_prompts.split('***')
|
||||
|
||||
binary_matrixes = []
|
||||
colors_fixed = []
|
||||
|
||||
im2arr = np.array(Image.open(layout_path))[:,:,:3]
|
||||
unique, counts = np.unique(np.reshape(im2arr,(-1,3)), axis=0, return_counts=True)
|
||||
sorted_idx = np.argsort(-counts)
|
||||
|
||||
binary_matrix = create_binary_matrix(im2arr, (0,0,0))
|
||||
binary_matrixes.append(binary_matrix)
|
||||
binary_matrix_ = np.repeat(np.expand_dims(binary_matrix, axis=(-1)), 3, axis=(-1))
|
||||
colored_map = binary_matrix_*(255,255,255) + (1-binary_matrix_)*(50,50,50)
|
||||
colors_fixed.append(gr.update(value=colored_map.astype(np.uint8)))
|
||||
|
||||
for i in range(len(all_prompts)-1):
|
||||
r, g, b = unique[sorted_idx[i]]
|
||||
if any(c != 255 for c in (r, g, b)) and any(c != 0 for c in (r, g, b)):
|
||||
binary_matrix = create_binary_matrix(im2arr, (r,g,b))
|
||||
binary_matrixes.append(binary_matrix)
|
||||
binary_matrix_ = np.repeat(np.expand_dims(binary_matrix, axis=(-1)), 3, axis=(-1))
|
||||
colored_map = binary_matrix_*(r,g,b) + (1-binary_matrix_)*(50,50,50)
|
||||
colors_fixed.append(gr.update(value=colored_map.astype(np.uint8)))
|
||||
|
||||
visibilities = []
|
||||
colors = []
|
||||
prompts = []
|
||||
for n in range(MAX_COLORS):
|
||||
visibilities.append(gr.update(visible=False))
|
||||
colors.append(gr.update())
|
||||
prompts.append(gr.update())
|
||||
|
||||
for n in range(len(colors_fixed)):
|
||||
visibilities[n] = gr.update(visible=True)
|
||||
colors[n] = colors_fixed[n]
|
||||
prompts[n] = all_prompts[n+1]
|
||||
|
||||
return [gr.update(visible=True), binary_matrixes, *visibilities, *colors, *prompts,
|
||||
gr.update(visible=True), gr.update(value=all_prompts[0]), int(seed_)]
|
||||
Reference in New Issue
Block a user