The most powerful and modular diffusion model GUI, api and backend with a graph/nodes interface. The fastest local inference engine in the world.
Refactor the attention functions.
comfyanonymous1a4bd9e9a6fc
diff --git a/comfy/ldm/modules/attention.py b/comfy/ldm/modules/attention.pyindex fcae6b66a..3230cfaf5 100644--- a/comfy/ldm/modules/attention.py+++ b/comfy/ldm/modules/attention.py@@ -94,360 +94,222 @@ def zero_module(module):def Normalize(in_channels, dtype=None, device=None):return torch.nn.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True, dtype=dtype, device=device)+def attention_basic(q, k, v, heads, mask=None):+ h = heads+ scale = (q.shape[-1] // heads) ** -0.5+ q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> (b h) n d', h=h), (q, k, v))++ # force cast to fp32 to avoid overflowing+ if _ATTN_PRECISION =="fp32":+ with torch.autocast(enabled=False, device_type = 'cuda'):+ q, k = q.float(), k.float()+ sim = einsum('b i d, b j d -> b i j', q, k) * scale+ else:+ sim = einsum('b i d, b j d -> b i j', q, k) * scale-class SpatialSelfAttention(nn.Module):- def __init__(self, in_channels):- super().__init__()- self.in_channels = in_channels-- self.norm = Normalize(in_channels)- self.q = torch.nn.Conv2d(in_channels,- in_channels,- kernel_size=1,- stride=1,- padding=0)- self.k = torch.nn.Conv2d(in_channels,- in_channels,- kernel_size=1,- stride=1,- padding=0)- self.v = torch.nn.Conv2d(in_channels,- in_channels,- kernel_size=1,- stride=1,- padding=0)- self.proj_out = torch.nn.Conv2d(in_channels,- in_channels,- kernel_size=1,- stride=1,- padding=0)-- def forward(self, x):- h_ = x- h_ = self.norm(h_)- q = self.q(h_)- k = self.k(h_)- v = self.v(h_)-- # compute attention- b,c,h,w = q.shape- q = rearrange(q, 'b c h w -> b (h w) c')- k = rearrange(k, 'b c h w -> b c (h w)')- w_ = torch.einsum('bij,bjk->bik', q, k)-- w_ = w_ * (int(c)**(-0.5))- w_ = torch.nn.functional.softmax(w_, dim=2)-- # attend to values- v = rearrange(v, 'b c h w -> b c (h w)')- w_ = rearrange(w_, 'b i j -> b j i')- h_ = torch.einsum('bij,bjk->bik', v, w_)- h_ = rearrange(h_, 'b c (h w) -> b c h w', h=h)- h_ = self.proj_out(h_)-- return x+h_---class CrossAttentionBirchSan(nn.Module):- def __init__(self, query_dim, context_dim=None, heads=8, dim_head=64, dropout=0., dtype=None, device=None, operations=comfy.ops):- super().__init__()- inner_dim = dim_head * heads- context_dim = default(context_dim, query_dim)-- self.scale = dim_head ** -0.5- self.heads = heads-- self.to_q = operations.Linear(query_dim, inner_dim, bias=False, dtype=dtype, device=device)- self.to_k = operations.Linear(context_dim, inner_dim, bias=False, dtype=dtype, device=device)- self.to_v = operations.Linear(context_dim, inner_dim, bias=False, dtype=dtype, device=device)-- self.to_out = nn.Sequential(- operations.Linear(inner_dim, query_dim, dtype=dtype, device=device),- nn.Dropout(dropout)- )-- def forward(self, x, context=None, value=None, mask=None):- h = self.heads-- query = self.to_q(x)- context = default(context, x)- key = self.to_k(context)- if value is not None:- value = self.to_v(value)- else:- value = self.to_v(context)-- del context, x-- query = query.unflatten(-1, (self.heads, -1)).transpose(1,2).flatten(end_dim=1)- key_t = key.transpose(1,2).unflatten(1, (self.heads, -1)).flatten(end_dim=1)- del key- value = value.unflatten(-1, (self.heads, -1)).transpose(1,2).flatten(end_dim=1)-- dtype = query.dtype- upcast_attention = _ATTN_PRECISION =="fp32" and query.dtype != torch.float32- if upcast_attention:- bytes_per_token = torch.finfo(torch.float32).bits//8- else:- bytes_per_token = torch.finfo(query.dtype).bits//8- batch_x_heads, q_tokens, _ = query.shape- _, _, k_tokens = key_t.shape- qk_matmul_size_bytes = batch_x_heads * bytes_per_token * q_tokens * k_tokens-- mem_free_total, mem_free_torch = model_management.get_free_memory(query.device, True)-- chunk_threshold_bytes = mem_free_torch * 0.5 #Using only this seems to work better on AMD-- kv_chunk_size_min = None-- #not sure at all about the math here- #TODO: tweak this- if mem_free_total > 8192 * 1024 * 1024 * 1.3:- query_chunk_size_x = 1024 * 4- elif mem_free_total > 4096 * 1024 * 1024 * 1.3:- query_chunk_size_x = 1024 * 2- else:- query_chunk_size_x = 1024- kv_chunk_size_min_x = None- kv_chunk_size_x = (int((chunk_threshold_bytes // (batch_x_heads * bytes_per_token * query_chunk_size_x)) * 2.0) // 1024) * 1024- if kv_chunk_size_x < 1024:- kv_chunk_size_x = None-- if chunk_threshold_bytes is not None and qk_matmul_size_bytes <= chunk_threshold_bytes:- # the big matmul fits into our memory limit; do everything in 1 chunk,- # i.e. send it down the unchunked fast-path- query_chunk_size = q_tokens- kv_chunk_size = k_tokens- else:- query_chunk_size = query_chunk_size_x- kv_chunk_size = kv_chunk_size_x- kv_chunk_size_min = kv_chunk_size_min_x-- hidden_states = efficient_dot_product_attention(- query,- key_t,- value,- query_chunk_size=query_chunk_size,- kv_chunk_size=kv_chunk_size,- kv_chunk_size_min=kv_chunk_size_min,- use_checkpoint=self.training,- upcast_attention=upcast_attention,- )-- hidden_states = hidden_states.to(dtype)+ del q, k- hidden_states = hidden_states.unflatten(0, (-1, self.heads)).transpose(1,2).flatten(start_dim=2)+ if exists(mask):+ mask = rearrange(mask, 'b ... -> b (...)')+ max_neg_value = -torch.finfo(sim.dtype).max+ mask = repeat(mask, 'b j -> (b h) () j', h=h)+ sim.masked_fill_(~mask, max_neg_value)- out_proj, dropout = self.to_out- hidden_states = out_proj(hidden_states)- hidden_states = dropout(hidden_states)+ # attention, what we cannot get enough of+ sim = sim.softmax(dim=-1)- return hidden_states+ out = einsum('b i j, b j d -> b i d', sim.to(v.dtype), v)+ out = rearrange(out, '(b h) n d -> b n (h d)', h=h)+ return out-class CrossAttentionDoggettx(nn.Module):- def __init__(self, query_dim, context_dim=None, heads=8, dim_head=64, dropout=0., dtype=None, device=None, operations=comfy.ops):- super().__init__()- inner_dim = dim_head * heads- context_dim = default(context_dim, query_dim)+def attention_sub_quad(query, key, value, heads, mask=None):+ scale = (query.shape[-1] // heads) ** -0.5+ query = query.unflatten(-1, (heads, -1)).transpose(1,2).flatten(end_dim=1)+ key_t = key.transpose(1,2).unflatten(1, (heads, -1)).flatten(end_dim=1)+ del key+ value = value.unflatten(-1, (heads, -1)).transpose(1,2).flatten(end_dim=1)- self.scale = dim_head ** -0.5- self.heads = heads+ dtype = query.dtype+ upcast_attention = _ATTN_PRECISION =="fp32" and query.dtype != torch.float32+ if upcast_attention:+ bytes_per_token = torch.finfo(torch.float32).bits//8+ else:+ bytes_per_token = torch.finfo(query.dtype).bits//8+ batch_x_heads, q_tokens, _ = query.shape+ _, _, k_tokens = key_t.shape+ qk_matmul_size_bytes = batch_x_heads * bytes_per_token * q_tokens * k_tokens- self.to_q = operations.Linear(query_dim, inner_dim, bias=False, dtype=dtype, device=device)- self.to_k = operations.Linear(context_dim, inner_dim, bias=False, dtype=dtype, device=device)- self.to_v = operations.Linear(context_dim, inner_dim, bias=False, dtype=dtype, device=device)+ mem_free_total, mem_free_torch = model_management.get_free_memory(query.device, True)- self.to_out = nn.Sequential(- operations.Linear(inner_dim, query_dim, dtype=dtype, device=device),- nn.Dropout(dropout)- )+ chunk_threshold_bytes = mem_free_torch * 0.5 #Using only this seems to work better on AMD- def forward(self, x, context=None, value=None, mask=None):- h = self.heads+ kv_chunk_size_min = None- q_in = self.to_q(x)- context = default(context, x)- k_in = self.to_k(context)- if value is not None:- v_in = self.to_v(value)- del value- else:- v_in = self.to_v(context)- del context, x-- q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> (b h) n d', h=h), (q_in, k_in, v_in))- del q_in, k_in, v_in-- r1 = torch.zeros(q.shape[0], q.shape[1], v.shape[2], device=q.device, dtype=q.dtype)-- mem_free_total = model_management.get_free_memory(q.device)-- gb = 1024 ** 3- tensor_size = q.shape[0] * q.shape[1] * k.shape[1] * q.element_size()- modifier = 3 if q.element_size() == 2 else 2.5- mem_required = tensor_size * modifier- steps = 1--- if mem_required > mem_free_total:- steps = 2**(math.ceil(math.log(mem_required / mem_free_total, 2)))- # print(f"Expected tensor size:{tensor_size/gb:0.1f}GB, cuda free:{mem_free_cuda/gb:0.1f}GB "- # f"torch free:{mem_free_torch/gb:0.1f} total:{mem_free_total/gb:0.1f} steps:{steps}")-- if steps > 64:- max_res = math.floor(math.sqrt(math.sqrt(mem_free_total / 2.5)) / 8) * 64- raise RuntimeError(f'Not enough memory, use lower resolution (max approx. {max_res}x{max_res}). '- f'Need: {mem_required/64/gb:0.1f}GB free, Have:{mem_free_total/gb:0.1f}GB free')-- # print("steps", steps, mem_required, mem_free_total, modifier, q.element_size(), tensor_size)- first_op_done = False- cleared_cache = False- while True:- try:- slice_size = q.shape[1] // steps if (q.shape[1] % steps) == 0 else q.shape[1]- for i in range(0, q.shape[1], slice_size):- end = i + slice_size- if _ATTN_PRECISION =="fp32":- with torch.autocast(enabled=False, device_type = 'cuda'):- s1 = einsum('b i d, b j d -> b i j', q[:, i:end].float(), k.float()) * self.scale- else:- s1 = einsum('b i d, b j d -> b i j', q[:, i:end], k) * self.scale- first_op_done = True-- s2 = s1.softmax(dim=-1).to(v.dtype)- del s1-- r1[:, i:end] = einsum('b i j, b j d -> b i d', s2, v)- del s2- break- except model_management.OOM_EXCEPTION as e:- if first_op_done == False:- model_management.soft_empty_cache(True)- if cleared_cache == False:- cleared_cache = True- print("out of memory error, emptying cache and trying again")- continue- steps *= 2- if steps > 64:- raise e- print("out of memory error, increasing steps and trying again", steps)+ #not sure at all about the math here+ #TODO: tweak this+ if mem_free_total > 8192 * 1024 * 1024 * 1.3:+ query_chunk_size_x = 1024 * 4+ elif mem_free_total > 4096 * 1024 * 1024 * 1.3:+ query_chunk_size_x = 1024 * 2+ else:+ query_chunk_size_x = 1024+ kv_chunk_size_min_x = None+ kv_chunk_size_x = (int((chunk_threshold_bytes // (batch_x_heads * bytes_per_token * query_chunk_size_x)) * 2.0) // 1024) * 1024+ if kv_chunk_size_x < 1024:+ kv_chunk_size_x = None++ if chunk_threshold_bytes is not None and qk_matmul_size_bytes <= chunk_threshold_bytes:+ # the big matmul fits into our memory limit; do everything in 1 chunk,+ # i.e. send it down the unchunked fast-path+ query_chunk_size = q_tokens+ kv_chunk_size = k_tokens+ else:+ query_chunk_size = query_chunk_size_x+ kv_chunk_size = kv_chunk_size_x+ kv_chunk_size_min = kv_chunk_size_min_x++ hidden_states = efficient_dot_product_attention(+ query,+ key_t,+ value,+ query_chunk_size=query_chunk_size,+ kv_chunk_size=kv_chunk_size,+ kv_chunk_size_min=kv_chunk_size_min,+ use_checkpoint=False,+ upcast_attention=upcast_attention,+ )++ hidden_states = hidden_states.to(dtype)++ hidden_states = hidden_states.unflatten(0, (-1, heads)).transpose(1,2).flatten(start_dim=2)+ return hidden_states++def attention_split(q, k, v, heads, mask=None):+ scale = (q.shape[-1] // heads) ** -0.5+ h = heads+ q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> (b h) n d', h=h), (q, k, v))++ r1 = torch.zeros(q.shape[0], q.shape[1], v.shape[2], device=q.device, dtype=q.dtype)++ mem_free_total = model_management.get_free_memory(q.device)++ gb = 1024 ** 3+ tensor_size = q.shape[0] * q.shape[1] * k.shape[1] * q.element_size()+ modifier = 3 if q.element_size() == 2 else 2.5+ mem_required = tensor_size * modifier+ steps = 1+++ if mem_required > mem_free_total:+ steps = 2**(math.ceil(math.log(mem_required / mem_free_total, 2)))+ # print(f"Expected tensor size:{tensor_size/gb:0.1f}GB, cuda free:{mem_free_cuda/gb:0.1f}GB "+ # f"torch free:{mem_free_torch/gb:0.1f} total:{mem_free_total/gb:0.1f} steps:{steps}")++ if steps > 64:+ max_res = math.floor(math.sqrt(math.sqrt(mem_free_total / 2.5)) / 8) * 64+ raise RuntimeError(f'Not enough memory, use lower resolution (max approx. {max_res}x{max_res}). '+ f'Need: {mem_required/64/gb:0.1f}GB free, Have:{mem_free_total/gb:0.1f}GB free')++ # print("steps", steps, mem_required, mem_free_total, modifier, q.element_size(), tensor_size)+ first_op_done = False+ cleared_cache = False+ while True:+ try:+ slice_size = q.shape[1] // steps if (q.shape[1] % steps) == 0 else q.shape[1]+ for i in range(0, q.shape[1], slice_size):+ end = i + slice_size+ if _ATTN_PRECISION =="fp32":+ with torch.autocast(enabled=False, device_type = 'cuda'):+ s1 = einsum('b i d, b j d -> b i j', q[:, i:end].float(), k.float()) * scaleelse:+ s1 = einsum('b i d, b j d -> b i j', q[:, i:end], k) * scale+ first_op_done = True++ s2 = s1.softmax(dim=-1).to(v.dtype)+ del s1++ r1[:, i:end] = einsum('b i j, b j d -> b i d', s2, v)+ del s2+ break+ except model_management.OOM_EXCEPTION as e:+ if first_op_done == False:+ model_management.soft_empty_cache(True)+ if cleared_cache == False:+ cleared_cache = True+ print("out of memory error, emptying cache and trying again")+ continue+ steps *= 2+ if steps > 64:raise e+ print("out of memory error, increasing steps and trying again", steps)+ else:+ raise e++ del q, k, v++ r2 = rearrange(r1, '(b h) n d -> b n (h d)', h=h)+ del r1+ return r2++def attention_xformers(q, k, v, heads, mask=None):+ b, _, _ = q.shape+ q, k, v = map(+ lambda t: t.unsqueeze(3)+ .reshape(b, t.shape[1], heads, -1)+ .permute(0, 2, 1, 3)+ .reshape(b * heads, t.shape[1], -1)+ .contiguous(),+ (q, k, v),+ )++ # actually compute the attention, what we cannot get enough of+ out = xformers.ops.memory_efficient_attention(q, k, v, attn_bias=None)++ if exists(mask):+ raise NotImplementedError+ out = (+ out.unsqueeze(0)+ .reshape(b, heads, out.shape[1], -1)+ .permute(0, 2, 1, 3)+ .reshape(b, out.shape[1], -1)+ )+ return out++def attention_pytorch(q, k, v, heads, mask=None):+ b, _, dim_head = q.shape+ dim_head //= heads+ q, k, v = map(+ lambda t: t.view(b, -1, heads, dim_head).transpose(1, 2),+ (q, k, v),+ )++ out = torch.nn.functional.scaled_dot_product_attention(q, k, v, attn_mask=None, dropout_p=0.0, is_causal=False)++ if exists(mask):+ raise NotImplementedError+ out = (+ out.transpose(1, 2).reshape(b, -1, heads * dim_head)+ )+ return out++optimized_attention = attention_basic- del q, k, v-- r2 = rearrange(r1, '(b h) n d -> b n (h d)', h=h)- del r1-- return self.to_out(r2)+if model_management.xformers_enabled():+ print("Using xformers cross attention")+ optimized_attention = attention_xformers+elif model_management.pytorch_attention_enabled():+ print("Using pytorch cross attention")+ optimized_attention = attention_pytorch+else:+ if args.use_split_cross_attention:+ print("Using split optimization for cross attention")+ optimized_attention = attention_split+ else:+ print("Using sub quadratic optimization for cross attention, if you have memory or speed issues try using: --use-split-cross-attention")+ optimized_attention = attention_sub_quadclass CrossAttention(nn.Module):- def __init__(self, query_dim, context_dim=None, heads=8, dim_head=64, dropout=0., dtype=None, device=None, operations=comfy.ops):- super().__init__()- inner_dim = dim_head * heads- context_dim = default(context_dim, query_dim)-- self.scale = dim_head ** -0.5- self.heads = heads-- self.to_q = operations.Linear(query_dim, inner_dim, bias=False, dtype=dtype, device=device)- self.to_k = operations.Linear(context_dim, inner_dim, bias=False, dtype=dtype, device=device)- self.to_v = operations.Linear(context_dim, inner_dim, bias=False, dtype=dtype, device=device)-- self.to_out = nn.Sequential(- operations.Linear(inner_dim, query_dim, dtype=dtype, device=device),- nn.Dropout(dropout)- )-- def forward(self, x, context=None, value=None, mask=None):- h = self.heads-- q = self.to_q(x)- context = default(context, x)- k = self.to_k(context)- if value is not None:- v = self.to_v(value)- del value- else:- v = self.to_v(context)-- q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> (b h) n d', h=h), (q, k, v))-- # force cast to fp32 to avoid overflowing- if _ATTN_PRECISION =="fp32":- with torch.autocast(enabled=False, device_type = 'cuda'):- q, k = q.float(), k.float()- sim = einsum('b i d, b j d -> b i j', q, k) * self.scale- else:- sim = einsum('b i d, b j d -> b i j', q, k) * self.scale-- del q, k-- if exists(mask):- mask = rearrange(mask, 'b ... -> b (...)')- max_neg_value = -torch.finfo(sim.dtype).max- mask = repeat(mask, 'b j -> (b h) () j', h=h)- sim.masked_fill_(~mask, max_neg_value)-- # attention, what we cannot get enough of- sim = sim.softmax(dim=-1)-- out = einsum('b i j, b j d -> b i d', sim, v)- out = rearrange(out, '(b h) n d -> b n (h d)', h=h)- return self.to_out(out)--class MemoryEfficientCrossAttention(nn.Module):- # https://github.com/MatthieuTPHR/diffusers/blob/d80b531ff8060ec1ea982b65a1b8df70f73aa67c/src/diffusers/models/attention.py#L223- def __init__(self, query_dim, context_dim=None, heads=8, dim_head=64, dropout=0.0, dtype=None, device=None, operations=comfy.ops):- super().__init__()- inner_dim = dim_head * heads- context_dim = default(context_dim, query_dim)-- self.heads = heads- self.dim_head = dim_head-- self.to_q = operations.Linear(query_dim, inner_dim, bias=False, dtype=dtype, device=device)- self.to_k = operations.Linear(context_dim, inner_dim, bias=False, dtype=dtype, device=device)- self.to_v = operations.Linear(context_dim, inner_dim, bias=False, dtype=dtype, device=device)-- self.to_out = nn.Sequential(operations.Linear(inner_dim, query_dim, dtype=dtype, device=device), nn.Dropout(dropout))- self.attention_op: Optional[Any] = None-- def forward(self, x, context=None, value=None, mask=None):- q = self.to_q(x)- context = default(context, x)- k = self.to_k(context)- if value is not None:- v = self.to_v(value)- del value- else:- v = self.to_v(context)-- b, _, _ = q.shape- q, k, v = map(- lambda t: t.unsqueeze(3)- .reshape(b, t.shape[1], self.heads, self.dim_head)- .permute(0, 2, 1, 3)- .reshape(b * self.heads, t.shape[1], self.dim_head)- .contiguous(),- (q, k, v),- )-- # actually compute the attention, what we cannot get enough of- out = xformers.ops.memory_efficient_attention(q, k, v, attn_bias=None, op=self.attention_op)-- if exists(mask):- raise NotImplementedError- out = (- out.unsqueeze(0)- .reshape(b, self.heads, out.shape[1], self.dim_head)- .permute(0, 2, 1, 3)- .reshape(b, out.shape[1], self.heads * self.dim_head)- )- return self.to_out(out)--class CrossAttentionPytorch(nn.Module):def __init__(self, query_dim, context_dim=None, heads=8, dim_head=64, dropout=0., dtype=None, device=None, operations=comfy.ops):super().__init__()inner_dim = dim_head * heads@@ -461,7 +323,6 @@ class CrossAttentionPytorch(nn.Module):self.to_v = operations.Linear(context_dim, inner_dim, bias=False, dtype=dtype, device=device)self.to_out = nn.Sequential(operations.Linear(inner_dim, query_dim, dtype=dtype, device=device), nn.Dropout(dropout))- self.attention_op: Optional[Any] = Nonedef forward(self, x, context=None, value=None, mask=None):q = self.to_q(x)@@ -473,36 +334,9 @@ class CrossAttentionPytorch(nn.Module):else:v = self.to_v(context)- b, _, _ = q.shape- q, k, v = map(- lambda t: t.view(b, -1, self.heads, self.dim_head).transpose(1, 2),- (q, k, v),- )-- out = torch.nn.functional.scaled_dot_product_attention(q, k, v, attn_mask=None, dropout_p=0.0, is_causal=False)-- if exists(mask):- raise NotImplementedError- out = (- out.transpose(1, 2).reshape(b, -1, self.heads * self.dim_head)- )-+ out = optimized_attention(q, k, v, self.heads, mask)return self.to_out(out)-if model_management.xformers_enabled():- print("Using xformers cross attention")- CrossAttention = MemoryEfficientCrossAttention-elif model_management.pytorch_attention_enabled():- print("Using pytorch cross attention")- CrossAttention = CrossAttentionPytorch-else:- if args.use_split_cross_attention:- print("Using split optimization for cross attention")- CrossAttention = CrossAttentionDoggettx- else:- print("Using sub quadratic optimization for cross attention, if you have memory or speed issues try using: --use-split-cross-attention")- CrossAttention = CrossAttentionBirchSan-class BasicTransformerBlock(nn.Module):def __init__(self, dim, n_heads, d_head, dropout=0., context_dim=None, gated_ff=True, checkpoint=True,diff --git a/comfy/ldm/modules/diffusionmodules/model.py b/comfy/ldm/modules/diffusionmodules/model.pyindex 5f38640c3..e6cf954ff 100644--- a/comfy/ldm/modules/diffusionmodules/model.py+++ b/comfy/ldm/modules/diffusionmodules/model.py@@ -6,7 +6,6 @@ import numpy as npfrom einops import rearrangefrom typing import Optional, Any-from ..attention import MemoryEfficientCrossAttentionfrom comfy import model_managementimport comfy.ops@@ -352,15 +351,6 @@ class MemoryEfficientAttnBlockPytorch(nn.Module):out = self.proj_out(out)return x+out-class MemoryEfficientCrossAttentionWrapper(MemoryEfficientCrossAttention):- def forward(self, x, context=None, mask=None):- b, c, h, w = x.shape- x = rearrange(x, 'b c h w -> b (h w) c')- out = super().forward(x, context=context, mask=mask)- out = rearrange(out, 'b (h w) c -> b c h w', h=h, w=w, c=c)- return x + out--def make_attn(in_channels, attn_type="vanilla", attn_kwargs=None):assert attn_type in ["vanilla", "vanilla-xformers", "memory-efficient-cross-attn", "linear", "none"], f'attn_type {attn_type} unknown'if model_management.xformers_enabled_vae() and attn_type == "vanilla":@@ -376,9 +366,6 @@ def make_attn(in_channels, attn_type="vanilla", attn_kwargs=None):return MemoryEfficientAttnBlock(in_channels)elif attn_type == "vanilla-pytorch":return MemoryEfficientAttnBlockPytorch(in_channels)- elif type == "memory-efficient-cross-attn":- attn_kwargs["query_dim"] = in_channels- return MemoryEfficientCrossAttentionWrapper(**attn_kwargs)elif attn_type == "none":return nn.Identity(in_channels)else: