Update docstring:

- mention no text encoder support yet
- make it clear that LoRA is meant
- mention that same adapter name should be passed

Author: BenjaminBossan

src/diffusers/loaders/lora_pipeline.py

@@ -83,8 +83,7 @@ def load_lora_weights(
         hotswap: bool = False,
         **kwargs,
     ):
-        """
-        Load LoRA weights specified in `pretrained_model_name_or_path_or_dict` into `self.unet` and
+        """Load LoRA weights specified in `pretrained_model_name_or_path_or_dict` into `self.unet` and
         `self.text_encoder`.
 
         All kwargs are forwarded to `self.lora_state_dict`.
@@ -108,11 +107,12 @@ def load_lora_weights(
                 Speed up model loading by only loading the pretrained LoRA weights and not initializing the random
                 weights.
             hotswap : (`bool`, *optional*)
-                Defaults to `False`. Whether to substitute an existing adapter with the newly loaded adapter in-place.
-                This means that, instead of loading an additional adapter, this will take the existing adapter weights
-                and replace them with the weights of the new adapter. This can be faster and more memory efficient.
-                However, the main advantage of hotswapping is that when the model is compiled with torch.compile,
-                loading the new adapter does not require recompilation of the model.
+                Defaults to `False`. Whether to substitute an existing (LoRA) adapter with the newly loaded adapter
+                in-place. This means that, instead of loading an additional adapter, this will take the existing
+                adapter weights and replace them with the weights of the new adapter. This can be faster and more
+                memory efficient. However, the main advantage of hotswapping is that when the model is compiled with
+                torch.compile, loading the new adapter does not require recompilation of the model. When using
+                hotswapping, the passed `adapter_name` should be the name of an already loaded adapter.
 
                 If the new adapter and the old adapter have different ranks and/or LoRA alphas (i.e. scaling), you need
                 to call an additional method before loading the adapter:
@@ -126,10 +126,12 @@ def load_lora_weights(
                 # optionally compile the model now
                 ```
 
-                There are some limitations to this technique, which are documented here:
+                Note that hotswapping adapters of the text encoder is not yet supported. There are some further
+                limitations to this technique, which are documented here:
                 https://huggingface.co/docs/peft/main/en/package_reference/hotswap
             kwargs (`dict`, *optional*):
                 See [`~loaders.StableDiffusionLoraLoaderMixin.lora_state_dict`].
+
         """
         if not USE_PEFT_BACKEND:
             raise ValueError("PEFT backend is required for this method.")
@@ -320,11 +322,12 @@ def load_lora_into_unet(
                 Speed up model loading only loading the pretrained LoRA weights and not initializing the random
                 weights.
             hotswap : (`bool`, *optional*)
-                Defaults to `False`. Whether to substitute an existing adapter with the newly loaded adapter in-place.
-                This means that, instead of loading an additional adapter, this will take the existing adapter weights
-                and replace them with the weights of the new adapter. This can be faster and more memory efficient.
-                However, the main advantage of hotswapping is that when the model is compiled with torch.compile,
-                loading the new adapter does not require recompilation of the model.
+                Defaults to `False`. Whether to substitute an existing (LoRA) adapter with the newly loaded adapter
+                in-place. This means that, instead of loading an additional adapter, this will take the existing
+                adapter weights and replace them with the weights of the new adapter. This can be faster and more
+                memory efficient. However, the main advantage of hotswapping is that when the model is compiled with
+                torch.compile, loading the new adapter does not require recompilation of the model. When using
+                hotswapping, the passed `adapter_name` should be the name of an already loaded adapter.
 
                 If the new adapter and the old adapter have different ranks and/or LoRA alphas (i.e. scaling), you need
                 to call an additional method before loading the adapter:
@@ -338,7 +341,8 @@ def load_lora_into_unet(
                 # optionally compile the model now
                 ```
 
-                There are some limitations to this technique, which are documented here:
+                Note that hotswapping adapters of the text encoder is not yet supported. There are some further
+                limitations to this technique, which are documented here:
                 https://huggingface.co/docs/peft/main/en/package_reference/hotswap
         """
         if not USE_PEFT_BACKEND:
@@ -405,13 +409,17 @@ def load_lora_into_text_encoder(
                 Speed up model loading by only loading the pretrained LoRA weights and not initializing the random
                 weights.
             hotswap : (`bool`, *optional*)
-                Defaults to `False`. Whether to substitute an existing adapter with the newly loaded adapter in-place.
-                This means that, instead of loading an additional adapter, this will take the existing adapter weights
-                and replace them with the weights of the new adapter. This can be faster and more memory efficient.
-                However, the main advantage of hotswapping is that when the model is compiled with torch.compile,
-                loading the new adapter does not require recompilation of the model. If the new adapter and the old
-                adapter have different ranks and/or LoRA alphas (i.e. scaling), you need to call an additional method
-                before loading the adapter:
+            hotswap : (`bool`, *optional*)
+                Defaults to `False`. Whether to substitute an existing (LoRA) adapter with the newly loaded adapter
+                in-place. This means that, instead of loading an additional adapter, this will take the existing
+                adapter weights and replace them with the weights of the new adapter. This can be faster and more
+                memory efficient. However, the main advantage of hotswapping is that when the model is compiled with
+                torch.compile, loading the new adapter does not require recompilation of the model. When using
+                hotswapping, the passed `adapter_name` should be the name of an already loaded adapter.
+
+                If the new adapter and the old adapter have different ranks and/or LoRA alphas (i.e. scaling), you need
+                to call an additional method before loading the adapter:
+
                 ```py
                 pipeline = ...  # load diffusers pipeline
                 max_rank = ...  # the highest rank among all LoRAs that you want to load
@@ -420,7 +428,9 @@ def load_lora_into_text_encoder(
                 pipeline.load_lora_weights(file_name)
                 # optionally compile the model now
                 ```
-                There are some limitations to this technique, which are documented here:
+
+                Note that hotswapping adapters of the text encoder is not yet supported. There are some further
+                limitations to this technique, which are documented here:
                 https://huggingface.co/docs/peft/main/en/package_reference/hotswap
         """
         _load_lora_into_text_encoder(
@@ -809,11 +819,12 @@ def load_lora_into_unet(
                 Speed up model loading only loading the pretrained LoRA weights and not initializing the random
                 weights.
             hotswap : (`bool`, *optional*)
-                Defaults to `False`. Whether to substitute an existing adapter with the newly loaded adapter in-place.
-                This means that, instead of loading an additional adapter, this will take the existing adapter weights
-                and replace them with the weights of the new adapter. This can be faster and more memory efficient.
-                However, the main advantage of hotswapping is that when the model is compiled with torch.compile,
-                loading the new adapter does not require recompilation of the model.
+                Defaults to `False`. Whether to substitute an existing (LoRA) adapter with the newly loaded adapter
+                in-place. This means that, instead of loading an additional adapter, this will take the existing
+                adapter weights and replace them with the weights of the new adapter. This can be faster and more
+                memory efficient. However, the main advantage of hotswapping is that when the model is compiled with
+                torch.compile, loading the new adapter does not require recompilation of the model. When using
+                hotswapping, the passed `adapter_name` should be the name of an already loaded adapter.
 
                 If the new adapter and the old adapter have different ranks and/or LoRA alphas (i.e. scaling), you need
                 to call an additional method before loading the adapter:
@@ -827,7 +838,8 @@ def load_lora_into_unet(
                 # optionally compile the model now
                 ```
 
-                There are some limitations to this technique, which are documented here:
+                Note that hotswapping adapters of the text encoder is not yet supported. There are some further
+                limitations to this technique, which are documented here:
                 https://huggingface.co/docs/peft/main/en/package_reference/hotswap
         """
         if not USE_PEFT_BACKEND:

src/diffusers/loaders/peft.py

@@ -148,7 +148,8 @@ def _optionally_disable_offloading(cls, _pipeline):
     def load_lora_adapter(
         self, pretrained_model_name_or_path_or_dict, prefix="transformer", hotswap: bool = False, **kwargs
     ):
-        r"""Loads a LoRA adapter into the underlying model.
+        r"""
+        Loads a LoRA adapter into the underlying model.
 
         Parameters:
             pretrained_model_name_or_path_or_dict (`str` or `os.PathLike` or `dict`):
@@ -191,14 +192,15 @@ def load_lora_adapter(
                 Speed up model loading by only loading the pretrained LoRA weights and not initializing the random
                 weights.
             hotswap : (`bool`, *optional*)
-                Defaults to `False`. Whether to substitute an existing adapter with the newly loaded adapter in-place.
-                This means that, instead of loading an additional adapter, this will take the existing adapter weights
-                and replace them with the weights of the new adapter. This can be faster and more memory efficient.
-                However, the main advantage of hotswapping is that when the model is compiled with torch.compile,
-                loading the new adapter does not require recompilation of the model.
+                Defaults to `False`. Whether to substitute an existing (LoRA) adapter with the newly loaded adapter
+                in-place. This means that, instead of loading an additional adapter, this will take the existing
+                adapter weights and replace them with the weights of the new adapter. This can be faster and more
+                memory efficient. However, the main advantage of hotswapping is that when the model is compiled with
+                torch.compile, loading the new adapter does not require recompilation of the model. When using
+                hotswapping, the passed `adapter_name` should be the name of an already loaded adapter.
 
-                If the model is compiled, or if the new adapter and the old adapter have different ranks and/or LoRA
-                alphas (i.e. scaling), you need to call an additional method before loading the adapter:
+                If the new adapter and the old adapter have different ranks and/or LoRA alphas (i.e. scaling), you need
+                to call an additional method before loading the adapter:
 
                 ```py
                 pipeline = ...  # load diffusers pipeline
@@ -209,9 +211,9 @@ def load_lora_adapter(
                 # optionally compile the model now
                 ```
 
-                There are some limitations to this technique, which are documented here:
+                Note that hotswapping adapters of the text encoder is not yet supported. There are some further
+                limitations to this technique, which are documented here:
                 https://huggingface.co/docs/peft/main/en/package_reference/hotswap
-
         """
         from peft import LoraConfig, inject_adapter_in_model, set_peft_model_state_dict
         from peft.tuners.tuners_utils import BaseTunerLayer