invoke-ai/InvokeAI · error · ValueError

LoRA "{lora_key}" already applied to transformer.

Error message

LoRA "{lora_key}" already applied to transformer.

What it means

The Flux2Klein LoRA loader invocation raised a ValueError because the given LoRA key is already present in the transformer's attached LoRA list. This library throws it to prevent the same LoRA from being applied twice to the FLUX.2 Klein transformer, which would double its weight contribution. It is a fail-fast duplicate-application guard inside invoke().

Source

Thrown at invokeai/app/invocations/flux2_klein_lora_loader.py:104

        lora_config = context.models.get_config(lora_key)
        # Reject cross-family (dev) LoRAs regardless of which input they're wired to.
        _assert_not_dev_lora(context, lora_config)

        # Warn if LoRA variant doesn't match transformer variant (intra-Klein 4B/9B).
        lora_variant = getattr(lora_config, "variant", None)
        if lora_variant and self.transformer is not None:
            transformer_config = context.models.get_config(self.transformer.transformer.key)
            transformer_variant = getattr(transformer_config, "variant", None)
            if transformer_variant and lora_variant != transformer_variant:
                context.logger.warning(
                    f"LoRA variant mismatch: LoRA '{lora_config.name}' is for {lora_variant.value} "
                    f"but transformer is {transformer_variant.value}. This may cause shape errors."
                )

        # Check for existing LoRAs with the same key.
        if self.transformer and any(lora.lora.key == lora_key for lora in self.transformer.loras):
            raise ValueError(f'LoRA "{lora_key}" already applied to transformer.')
        if self.qwen3_encoder and any(lora.lora.key == lora_key for lora in self.qwen3_encoder.loras):
            raise ValueError(f'LoRA "{lora_key}" already applied to Qwen3 encoder.')

        output = Flux2KleinLoRALoaderOutput()

        # Attach LoRA layers to the models.
        if self.transformer is not None:
            output.transformer = self.transformer.model_copy(deep=True)
            output.transformer.loras.append(
                LoRAField(
                    lora=self.lora,
                    weight=self.weight,
                )
            )
        if self.qwen3_encoder is not None:
            output.qwen3_encoder = self.qwen3_encoder.model_copy(deep=True)
            output.qwen3_encoder.loras.append(
                LoRAField(

View on GitHub (pinned to 0b6a024f2f)

Solutions

1. Ensure each LoRA key appears only once in the LoRA collection fed to this loader node
2. Remove the duplicate LoRA entry from the loader input before re-running invoke()
3. Use a fresh transformer/loRA list for each invocation instead of reusing a mutated one
4. Catch ValueError around invoke() and skip already-applied keys

Example fix

// before: same LoRA listed twice
loras = [lora_a, lora_a]
output = loader.invoke(context)
// after: dedupe by key first
seen = set()
loras = [l for l in [lora_a, lora_a] if not (l.key in seen or seen.add(l.key))]
output = loader.invoke(context)

keys = [l.lora.key for l in loader_input_loras]
dupes = {k for k in keys if keys.count(k) > 1
          and any(l.lora.key == k for l in transformer.loras)}
if dupes:
    raise ValueError(f"LoRAs already applied to transformer: {dupes}")

def not_already_applied(key: str, transformer) -> bool:
    return not any(l.lora.key == key for l in transformer.loras)

try:
    output = loader.invoke(context)
except ValueError as e:
    if 'already applied to transformer' in str(e):
        key = str(e).split('"')[1]
        loader.transformer.loras = [l for l in loader.transformer.loras if l.lora.key != key]
        output = loader.invoke(context)
    else:
        raise

When it happens

Trigger: Calling invoke() on Flux2KleinLoRALoader when self.transformer is set and any(lora.lora.key == lora_key for lora in self.transformer.loras) is true — i.e. the same LoRA model-key was already attached to the transformer's loras list earlier in the same graph run.

Common situations: Reusing a LoRA loader node across multiple graph executions without clearing state; the same LoRA referenced by two loader nodes feeding one transformer; loops that re-invoke the loader with an already-populated transformer.

Related errors

• LoRA "{lora_key}" already applied to transformer.
• LoRA "{lora_key}" already applied to Qwen3 encoder.
• LoRA "{lora_key}" already applied to Qwen3 encoder.
• LoRA '{lora.lora.key}' is for {lora.lora.base.value if lora.
• LoRA "{lora_key}" already applied to primary transformer lis

AI-assisted analysis of invoke-ai/InvokeAI@0b6a024f2f (2026-08-29). Data as JSON: /api/errors/7eb567d65e9b3597. Report an issue: GitHub.