Implementation:AUTOMATIC1111 Stable diffusion webui Load networks
| Knowledge Sources | |
|---|---|
| Domains | Stable Diffusion, LoRA, LyCORIS, Model Loading, Low-Rank Adaptation |
| Last Updated | 2026-02-08 00:00 GMT |
Overview
Concrete tool for loading LoRA and LyCORIS network adapter files, matching their keys to Stable Diffusion model layers, and constructing typed NetworkModule instances, provided by the AUTOMATIC1111 stable-diffusion-webui repository.
Description
The load_networks() function is the primary entry point for loading a set of named network adapters. It resolves network names to files on disk via available_networks and available_network_aliases, checks an in-memory cache for previously loaded networks, and falls back to load_network() for fresh loads. Each loaded network is assigned its text encoder multiplier, UNet multiplier, and dynamic dimension, then appended to the global loaded_networks list.
The inner load_network() function reads the state dict from the file, iterates over all keys, converts diffusers-format keys to CompVis format, matches each key against the model's network_layer_mapping, groups matched weights by layer, and passes each group through the chain of module type factories (ModuleTypeLora, ModuleTypeHada, ModuleTypeIa3, ModuleTypeLokr, ModuleTypeFull, ModuleTypeNorm, ModuleTypeGLora, ModuleTypeOFT) to create the appropriate NetworkModule instance.
Bundle embeddings (textual inversions embedded within the network file under the bundle_emb prefix) are extracted and registered with the embedding database.
Usage
This function is called by ExtraNetworkLora.activate() whenever the prompt-specified set of LoRA networks changes. It should not be called directly by external code; the activation pipeline handles orchestration.
Code Reference
Source Location
- Repository: stable-diffusion-webui
- File:
extensions-builtin/Lora/networks.py - Lines: 281-366 (load_networks), 158-270 (load_network)
Signature
def load_networks(names, te_multipliers=None, unet_multipliers=None, dyn_dims=None):
"""
Load a set of named network adapters, setting per-network multipliers.
Resolves names to on-disk files, uses in-memory cache when available,
loads fresh from disk when needed, and populates the global loaded_networks list.
Also handles bundled textual inversion embeddings.
"""
emb_db = sd_hijack.model_hijack.embedding_db
already_loaded = {}
for net in loaded_networks:
if net.name in names:
already_loaded[net.name] = net
for emb_name, embedding in net.bundle_embeddings.items():
if embedding.loaded:
emb_db.register_embedding_by_name(None, shared.sd_model, emb_name)
loaded_networks.clear()
unavailable_networks = []
for name in names:
if name.lower() in forbidden_network_aliases and available_networks.get(name) is None:
unavailable_networks.append(name)
elif available_network_aliases.get(name) is None:
unavailable_networks.append(name)
if unavailable_networks:
update_available_networks_by_names(unavailable_networks)
networks_on_disk = [
available_networks.get(name, None) if name.lower() in forbidden_network_aliases
else available_network_aliases.get(name, None)
for name in names
]
if any(x is None for x in networks_on_disk):
list_available_networks()
networks_on_disk = [
available_networks.get(name, None) if name.lower() in forbidden_network_aliases
else available_network_aliases.get(name, None)
for name in names
]
failed_to_load_networks = []
for i, (network_on_disk, name) in enumerate(zip(networks_on_disk, names)):
net = already_loaded.get(name, None)
if network_on_disk is not None:
if net is None:
net = networks_in_memory.get(name)
if net is None or os.path.getmtime(network_on_disk.filename) > net.mtime:
try:
net = load_network(name, network_on_disk)
networks_in_memory.pop(name, None)
networks_in_memory[name] = net
except Exception as e:
errors.display(e, f"loading network {network_on_disk.filename}")
continue
net.mentioned_name = name
network_on_disk.read_hash()
if net is None:
failed_to_load_networks.append(name)
logging.info(f"Couldn't find network with name {name}")
continue
net.te_multiplier = te_multipliers[i] if te_multipliers else 1.0
net.unet_multiplier = unet_multipliers[i] if unet_multipliers else 1.0
net.dyn_dim = dyn_dims[i] if dyn_dims else 1.0
loaded_networks.append(net)
...
if failed_to_load_networks:
lora_not_found_message = f'Lora not found: {", ".join(failed_to_load_networks)}'
sd_hijack.model_hijack.comments.append(lora_not_found_message)
...
purge_networks_from_memory()
Import
import networks
networks.load_networks(names, te_multipliers, unet_multipliers, dyn_dims)
I/O Contract
Inputs
| Name | Type | Required | Description |
|---|---|---|---|
| names | list[str] | Yes | List of network names or aliases to load |
| te_multipliers | list[float] or None | No | Per-network text encoder weight multipliers; defaults to 1.0 for each |
| unet_multipliers | list[float] or None | No | Per-network UNet weight multipliers; defaults to 1.0 for each |
| dyn_dims | list[int] or None | No | Per-network dynamic dimension (rank truncation) values; defaults to None |
Outputs
| Name | Type | Description |
|---|---|---|
| return | None | Side effect: populates the global loaded_networks list with network.Network instances, each containing a dict of NetworkModule objects keyed by layer name
|
Global state modified:
| Variable | Type | Description |
|---|---|---|
| loaded_networks | list[Network] | Cleared and repopulated with the requested networks |
| networks_in_memory | dict[str, Network] | Updated with newly loaded networks; oldest entries evicted when over limit |
Usage Examples
Basic Usage
import networks
# Load two LoRA networks with different multipliers
networks.load_networks(
names=["character_lora", "style_lora"],
te_multipliers=[0.8, 0.6],
unet_multipliers=[0.8, 0.4],
dyn_dims=[None, None]
)
# Inspect loaded networks
for net in networks.loaded_networks:
print(f"Network: {net.name}")
print(f" TE multiplier: {net.te_multiplier}")
print(f" UNet multiplier: {net.unet_multiplier}")
print(f" Modules: {len(net.modules)}")
for layer_name, module in net.modules.items():
print(f" {layer_name}: {type(module).__name__}")
Module Type Resolution
# The module_types chain determines which NetworkModule subclass is created:
module_types = [
network_lora.ModuleTypeLora(), # lora_up + lora_down
network_hada.ModuleTypeHada(), # hada_w1_a + hada_w1_b + hada_w2_a + hada_w2_b
network_ia3.ModuleTypeIa3(), # weight (IA3 scaling)
network_lokr.ModuleTypeLokr(), # lokr_w1 + lokr_w2
network_full.ModuleTypeFull(), # diff (full-rank delta)
network_norm.ModuleTypeNorm(), # w_norm + b_norm
network_glora.ModuleTypeGLora(), # a1 + a2 + b1 + b2
network_oft.ModuleTypeOFT(), # oft_blocks or oft_diag
]
# Each factory's create_module() inspects weight keys and returns
# a NetworkModule instance if the keys match, or None to pass to the next factory.