|
import torch |
|
|
|
from contextlib import contextmanager |
|
from typing import Union, Tuple |
|
|
|
|
|
_size_2_t = Union[int, Tuple[int, int]] |
|
|
|
|
|
class LinearWithLoRA(torch.nn.Module): |
|
def __init__( |
|
self, |
|
in_features: int, |
|
out_features: int, |
|
bias: bool = True, |
|
device=None, |
|
dtype=None) -> None: |
|
super().__init__() |
|
self.weight_module = None |
|
self.up = None |
|
self.down = None |
|
self.bias = None |
|
self.in_features = in_features |
|
self.out_features = out_features |
|
self.device = device |
|
self.dtype = dtype |
|
self.weight = None |
|
|
|
def bind_lora(self, weight_module): |
|
self.weight_module = [weight_module] |
|
|
|
def unbind_lora(self): |
|
if self.up is not None and self.down is not None: |
|
self.weight_module = None |
|
|
|
def get_original_weight(self): |
|
if self.weight_module is None: |
|
return None |
|
return self.weight_module[0].weight |
|
|
|
def forward(self, x): |
|
if self.weight is not None: |
|
return torch.nn.functional.linear(x, self.weight.to(x), |
|
self.bias.to(x) if self.bias is not None else None) |
|
|
|
original_weight = self.get_original_weight() |
|
|
|
if original_weight is None: |
|
return None |
|
|
|
if self.up is not None and self.down is not None: |
|
weight = original_weight.to(x) + torch.mm(self.up, self.down).to(x) |
|
else: |
|
weight = original_weight.to(x) |
|
|
|
return torch.nn.functional.linear(x, weight, self.bias.to(x) if self.bias is not None else None) |
|
|
|
|
|
class Conv2dWithLoRA(torch.nn.Module): |
|
def __init__( |
|
self, |
|
in_channels: int, |
|
out_channels: int, |
|
kernel_size: _size_2_t, |
|
stride: _size_2_t = 1, |
|
padding: Union[str, _size_2_t] = 0, |
|
dilation: _size_2_t = 1, |
|
groups: int = 1, |
|
bias: bool = True, |
|
padding_mode: str = 'zeros', |
|
device=None, |
|
dtype=None |
|
) -> None: |
|
super().__init__() |
|
self.stride = stride |
|
self.padding = padding |
|
self.dilation = dilation |
|
self.groups = groups |
|
self.weight_module = None |
|
self.bias = None |
|
self.up = None |
|
self.down = None |
|
self.in_channels = in_channels |
|
self.out_channels = out_channels |
|
self.kernel_size = kernel_size |
|
self.padding_mode = padding_mode |
|
self.device = device |
|
self.dtype = dtype |
|
self.weight = None |
|
|
|
def bind_lora(self, weight_module): |
|
self.weight_module = [weight_module] |
|
|
|
def unbind_lora(self): |
|
if self.up is not None and self.down is not None: |
|
self.weight_module = None |
|
|
|
def get_original_weight(self): |
|
if self.weight_module is None: |
|
return None |
|
return self.weight_module[0].weight |
|
|
|
def forward(self, x): |
|
if self.weight is not None: |
|
return torch.nn.functional.conv2d(x, self.weight.to(x), self.bias.to(x) if self.bias is not None else None, |
|
self.stride, self.padding, self.dilation, self.groups) |
|
|
|
original_weight = self.get_original_weight() |
|
|
|
if original_weight is None: |
|
return None |
|
|
|
if self.up is not None and self.down is not None: |
|
weight = original_weight.to(x) + torch.mm(self.up.flatten(start_dim=1), self.down.flatten(start_dim=1)).reshape(original_weight.shape).to(x) |
|
else: |
|
weight = original_weight.to(x) |
|
|
|
return torch.nn.functional.conv2d(x, weight, self.bias.to(x) if self.bias is not None else None, |
|
self.stride, self.padding, self.dilation, self.groups) |
|
|
|
|
|
@contextmanager |
|
def controlnet_lora_hijack(): |
|
linear, conv2d = torch.nn.Linear, torch.nn.Conv2d |
|
torch.nn.Linear, torch.nn.Conv2d = LinearWithLoRA, Conv2dWithLoRA |
|
try: |
|
yield |
|
finally: |
|
torch.nn.Linear, torch.nn.Conv2d = linear, conv2d |
|
|
|
|
|
def recursive_set(obj, key, value): |
|
if obj is None: |
|
return |
|
if '.' in key: |
|
k1, k2 = key.split('.', 1) |
|
recursive_set(getattr(obj, k1, None), k2, value) |
|
else: |
|
setattr(obj, key, value) |
|
|
|
|
|
def force_load_state_dict(model, state_dict): |
|
for k in list(state_dict.keys()): |
|
recursive_set(model, k, torch.nn.Parameter(state_dict[k])) |
|
del state_dict[k] |
|
return |
|
|
|
|
|
def recursive_bind_lora(obj, key, value): |
|
if obj is None: |
|
return |
|
if '.' in key: |
|
k1, k2 = key.split('.', 1) |
|
recursive_bind_lora(getattr(obj, k1, None), k2, value) |
|
else: |
|
target = getattr(obj, key, None) |
|
if target is not None and hasattr(target, 'bind_lora'): |
|
target.bind_lora(value) |
|
|
|
|
|
def recursive_get(obj, key): |
|
if obj is None: |
|
return |
|
if '.' in key: |
|
k1, k2 = key.split('.', 1) |
|
return recursive_get(getattr(obj, k1, None), k2) |
|
else: |
|
return getattr(obj, key, None) |
|
|
|
|
|
def bind_control_lora(base_model, control_lora_model): |
|
sd = base_model.state_dict() |
|
keys = list(sd.keys()) |
|
keys = list(set([k.rsplit('.', 1)[0] for k in keys])) |
|
module_dict = {k: recursive_get(base_model, k) for k in keys} |
|
for k, v in module_dict.items(): |
|
recursive_bind_lora(control_lora_model, k, v) |
|
|
|
|
|
def torch_dfs(model: torch.nn.Module): |
|
result = [model] |
|
for child in model.children(): |
|
result += torch_dfs(child) |
|
return result |
|
|
|
|
|
def unbind_control_lora(control_lora_model): |
|
for m in torch_dfs(control_lora_model): |
|
if hasattr(m, 'unbind_lora'): |
|
m.unbind_lora() |
|
return |
|
|