| 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 |
|
|
