334 lines
10 KiB
Python
334 lines
10 KiB
Python
import math
|
|
|
|
import torch
|
|
import torch.nn as nn
|
|
|
|
|
|
class MLPProjModel(torch.nn.Module):
|
|
def __init__(self, cross_attention_dim=1024, clip_embeddings_dim=1024):
|
|
super().__init__()
|
|
|
|
self.proj = torch.nn.Sequential(
|
|
torch.nn.Linear(clip_embeddings_dim, clip_embeddings_dim),
|
|
torch.nn.GELU(),
|
|
torch.nn.Linear(clip_embeddings_dim, cross_attention_dim),
|
|
torch.nn.LayerNorm(cross_attention_dim),
|
|
)
|
|
|
|
def forward(self, image_embeds):
|
|
clip_extra_context_tokens = self.proj(image_embeds)
|
|
return clip_extra_context_tokens
|
|
|
|
|
|
class MLPProjModelFaceId(torch.nn.Module):
|
|
"""MLPProjModel used for FaceId.
|
|
Source: https://github.com/tencent-ailab/IP-Adapter/blob/main/ip_adapter/ip_adapter_faceid.py
|
|
"""
|
|
|
|
def __init__(self, cross_attention_dim=768, id_embeddings_dim=512, num_tokens=4):
|
|
super().__init__()
|
|
|
|
self.cross_attention_dim = cross_attention_dim
|
|
self.num_tokens = num_tokens
|
|
|
|
self.proj = torch.nn.Sequential(
|
|
torch.nn.Linear(id_embeddings_dim, id_embeddings_dim * 2),
|
|
torch.nn.GELU(),
|
|
torch.nn.Linear(id_embeddings_dim * 2, cross_attention_dim * num_tokens),
|
|
)
|
|
self.norm = torch.nn.LayerNorm(cross_attention_dim)
|
|
|
|
def forward(self, id_embeds):
|
|
clip_extra_context_tokens = self.proj(id_embeds)
|
|
clip_extra_context_tokens = clip_extra_context_tokens.reshape(
|
|
-1, self.num_tokens, self.cross_attention_dim
|
|
)
|
|
clip_extra_context_tokens = self.norm(clip_extra_context_tokens)
|
|
return clip_extra_context_tokens
|
|
|
|
|
|
class FacePerceiverResampler(torch.nn.Module):
|
|
"""Source: https://github.com/tencent-ailab/IP-Adapter/blob/main/ip_adapter/ip_adapter_faceid.py"""
|
|
|
|
def __init__(
|
|
self,
|
|
*,
|
|
dim=768,
|
|
depth=4,
|
|
dim_head=64,
|
|
heads=16,
|
|
embedding_dim=1280,
|
|
output_dim=768,
|
|
ff_mult=4,
|
|
):
|
|
super().__init__()
|
|
|
|
self.proj_in = torch.nn.Linear(embedding_dim, dim)
|
|
self.proj_out = torch.nn.Linear(dim, output_dim)
|
|
self.norm_out = torch.nn.LayerNorm(output_dim)
|
|
self.layers = torch.nn.ModuleList([])
|
|
for _ in range(depth):
|
|
self.layers.append(
|
|
torch.nn.ModuleList(
|
|
[
|
|
PerceiverAttention(dim=dim, dim_head=dim_head, heads=heads),
|
|
FeedForward(dim=dim, mult=ff_mult),
|
|
]
|
|
)
|
|
)
|
|
|
|
def forward(self, latents, x):
|
|
x = self.proj_in(x)
|
|
for attn, ff in self.layers:
|
|
latents = attn(x, latents) + latents
|
|
latents = ff(latents) + latents
|
|
latents = self.proj_out(latents)
|
|
return self.norm_out(latents)
|
|
|
|
|
|
class ProjModelFaceIdPlus(torch.nn.Module):
|
|
"""Source: https://github.com/tencent-ailab/IP-Adapter/blob/main/ip_adapter/ip_adapter_faceid.py"""
|
|
|
|
def __init__(
|
|
self,
|
|
cross_attention_dim=768,
|
|
id_embeddings_dim=512,
|
|
clip_embeddings_dim=1280,
|
|
num_tokens=4,
|
|
):
|
|
super().__init__()
|
|
|
|
self.cross_attention_dim = cross_attention_dim
|
|
self.num_tokens = num_tokens
|
|
|
|
self.proj = torch.nn.Sequential(
|
|
torch.nn.Linear(id_embeddings_dim, id_embeddings_dim * 2),
|
|
torch.nn.GELU(),
|
|
torch.nn.Linear(id_embeddings_dim * 2, cross_attention_dim * num_tokens),
|
|
)
|
|
self.norm = torch.nn.LayerNorm(cross_attention_dim)
|
|
|
|
self.perceiver_resampler = FacePerceiverResampler(
|
|
dim=cross_attention_dim,
|
|
depth=4,
|
|
dim_head=64,
|
|
heads=cross_attention_dim // 64,
|
|
embedding_dim=clip_embeddings_dim,
|
|
output_dim=cross_attention_dim,
|
|
ff_mult=4,
|
|
)
|
|
|
|
def forward(self, id_embeds, clip_embeds, scale=1.0, shortcut=False):
|
|
x = self.proj(id_embeds)
|
|
x = x.reshape(-1, self.num_tokens, self.cross_attention_dim)
|
|
x = self.norm(x)
|
|
out = self.perceiver_resampler(x, clip_embeds)
|
|
if shortcut:
|
|
out = x + scale * out
|
|
return out
|
|
|
|
|
|
class ImageProjModel(torch.nn.Module):
|
|
"""Projection Model"""
|
|
|
|
def __init__(
|
|
self,
|
|
cross_attention_dim=1024,
|
|
clip_embeddings_dim=1024,
|
|
clip_extra_context_tokens=4,
|
|
):
|
|
super().__init__()
|
|
|
|
self.cross_attention_dim = cross_attention_dim
|
|
self.clip_extra_context_tokens = clip_extra_context_tokens
|
|
self.proj = torch.nn.Linear(
|
|
clip_embeddings_dim, self.clip_extra_context_tokens * cross_attention_dim
|
|
)
|
|
self.norm = torch.nn.LayerNorm(cross_attention_dim)
|
|
|
|
def forward(self, image_embeds):
|
|
embeds = image_embeds
|
|
clip_extra_context_tokens = self.proj(embeds).reshape(
|
|
-1, self.clip_extra_context_tokens, self.cross_attention_dim
|
|
)
|
|
clip_extra_context_tokens = self.norm(clip_extra_context_tokens)
|
|
return clip_extra_context_tokens
|
|
|
|
|
|
def FeedForward(dim, mult=4):
|
|
inner_dim = int(dim * mult)
|
|
return nn.Sequential(
|
|
nn.LayerNorm(dim),
|
|
nn.Linear(dim, inner_dim, bias=False),
|
|
nn.GELU(),
|
|
nn.Linear(inner_dim, dim, bias=False),
|
|
)
|
|
|
|
|
|
def reshape_tensor(x, heads):
|
|
bs, length, width = x.shape
|
|
# (bs, length, width) --> (bs, length, n_heads, dim_per_head)
|
|
x = x.view(bs, length, heads, -1)
|
|
# (bs, length, n_heads, dim_per_head) --> (bs, n_heads, length, dim_per_head)
|
|
x = x.transpose(1, 2)
|
|
# (bs, n_heads, length, dim_per_head) --> (bs*n_heads, length, dim_per_head)
|
|
x = x.reshape(bs, heads, length, -1)
|
|
return x
|
|
|
|
|
|
class PerceiverAttention(nn.Module):
|
|
def __init__(self, *, dim, dim_head=64, heads=8):
|
|
super().__init__()
|
|
self.scale = dim_head**-0.5
|
|
self.dim_head = dim_head
|
|
self.heads = heads
|
|
inner_dim = dim_head * heads
|
|
|
|
self.norm1 = nn.LayerNorm(dim)
|
|
self.norm2 = nn.LayerNorm(dim)
|
|
|
|
self.to_q = nn.Linear(dim, inner_dim, bias=False)
|
|
self.to_kv = nn.Linear(dim, inner_dim * 2, bias=False)
|
|
self.to_out = nn.Linear(inner_dim, dim, bias=False)
|
|
|
|
def forward(self, x, latents):
|
|
"""
|
|
Args:
|
|
x (torch.Tensor): image features
|
|
shape (b, n1, D)
|
|
latent (torch.Tensor): latent features
|
|
shape (b, n2, D)
|
|
"""
|
|
x = self.norm1(x)
|
|
latents = self.norm2(latents)
|
|
|
|
b, l, _ = latents.shape # noqa: E741
|
|
|
|
q = self.to_q(latents)
|
|
kv_input = torch.cat((x, latents), dim=-2)
|
|
k, v = self.to_kv(kv_input).chunk(2, dim=-1)
|
|
|
|
q = reshape_tensor(q, self.heads)
|
|
k = reshape_tensor(k, self.heads)
|
|
v = reshape_tensor(v, self.heads)
|
|
|
|
# attention
|
|
scale = 1 / math.sqrt(math.sqrt(self.dim_head))
|
|
weight = (q * scale) @ (k * scale).transpose(
|
|
-2, -1
|
|
) # More stable with f16 than dividing afterwards
|
|
weight = torch.softmax(weight.float(), dim=-1).type(weight.dtype)
|
|
out = weight @ v
|
|
|
|
out = out.permute(0, 2, 1, 3).reshape(b, l, -1)
|
|
|
|
return self.to_out(out)
|
|
|
|
|
|
class Resampler(nn.Module):
|
|
def __init__(
|
|
self,
|
|
dim=1024,
|
|
depth=8,
|
|
dim_head=64,
|
|
heads=16,
|
|
num_queries=8,
|
|
embedding_dim=768,
|
|
output_dim=1024,
|
|
ff_mult=4,
|
|
):
|
|
super().__init__()
|
|
|
|
self.latents = nn.Parameter(torch.randn(1, num_queries, dim) / dim**0.5)
|
|
|
|
self.proj_in = nn.Linear(embedding_dim, dim)
|
|
|
|
self.proj_out = nn.Linear(dim, output_dim)
|
|
self.norm_out = nn.LayerNorm(output_dim)
|
|
|
|
self.layers = nn.ModuleList([])
|
|
for _ in range(depth):
|
|
self.layers.append(
|
|
nn.ModuleList(
|
|
[
|
|
PerceiverAttention(dim=dim, dim_head=dim_head, heads=heads),
|
|
FeedForward(dim=dim, mult=ff_mult),
|
|
]
|
|
)
|
|
)
|
|
|
|
def forward(self, x):
|
|
|
|
latents = self.latents.repeat(x.size(0), 1, 1)
|
|
|
|
x = self.proj_in(x)
|
|
|
|
for attn, ff in self.layers:
|
|
latents = attn(x, latents) + latents
|
|
latents = ff(latents) + latents
|
|
|
|
latents = self.proj_out(latents)
|
|
return self.norm_out(latents)
|
|
|
|
|
|
class PuLIDEncoder(nn.Module):
|
|
def __init__(self, width=1280, context_dim=2048, num_token=5):
|
|
super().__init__()
|
|
self.num_token = num_token
|
|
self.context_dim = context_dim
|
|
h1 = min((context_dim * num_token) // 4, 1024)
|
|
h2 = min((context_dim * num_token) // 2, 1024)
|
|
self.body = nn.Sequential(
|
|
nn.Linear(width, h1),
|
|
nn.LayerNorm(h1),
|
|
nn.LeakyReLU(),
|
|
nn.Linear(h1, h2),
|
|
nn.LayerNorm(h2),
|
|
nn.LeakyReLU(),
|
|
nn.Linear(h2, context_dim * num_token),
|
|
)
|
|
|
|
for i in range(5):
|
|
setattr(
|
|
self,
|
|
f"mapping_{i}",
|
|
nn.Sequential(
|
|
nn.Linear(1024, 1024),
|
|
nn.LayerNorm(1024),
|
|
nn.LeakyReLU(),
|
|
nn.Linear(1024, 1024),
|
|
nn.LayerNorm(1024),
|
|
nn.LeakyReLU(),
|
|
nn.Linear(1024, context_dim),
|
|
),
|
|
)
|
|
|
|
setattr(
|
|
self,
|
|
f"mapping_patch_{i}",
|
|
nn.Sequential(
|
|
nn.Linear(1024, 1024),
|
|
nn.LayerNorm(1024),
|
|
nn.LeakyReLU(),
|
|
nn.Linear(1024, 1024),
|
|
nn.LayerNorm(1024),
|
|
nn.LeakyReLU(),
|
|
nn.Linear(1024, context_dim),
|
|
),
|
|
)
|
|
|
|
def forward(self, x, y):
|
|
# x shape [N, C]
|
|
x = self.body(x)
|
|
x = x.reshape(-1, self.num_token, self.context_dim)
|
|
|
|
hidden_states = ()
|
|
for i, emb in enumerate(y):
|
|
hidden_state = getattr(self, f"mapping_{i}")(emb[:, :1]) + getattr(
|
|
self, f"mapping_patch_{i}"
|
|
)(emb[:, 1:]).mean(dim=1, keepdim=True)
|
|
hidden_states += (hidden_state,)
|
|
hidden_states = torch.cat(hidden_states, dim=1)
|
|
|
|
return torch.cat([x, hidden_states], dim=1)
|