PEFT documentation

LoHa

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v0.22.0).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

LoHa

Navigating Text-To-Image Customization: From LyCORIS Fine-Tuning to Model Evaluation

El producto de Hadamard de bajo rango (LoHa) es similar a LoRA, excepto que aproxima la gran matriz de pesos con más matrices de bajo rango y las combina mediante el producto de Hadamard. Este método es aún más eficiente en parámetros que LoRA y logra un rendimiento comparable. LoHa se propuso originalmente para el aprendizaje federado (FedPara), pero funciona bien como un método PEFT de uso general y es especialmente popular para el ajuste fino de modelos de generación de imágenes, como Stable Diffusion.

Nota: LoHa forma parte de la familia de adaptadores LyCORIS. Su pariente cercano LoKr utiliza el producto de Kronecker en lugar del producto de Hadamard.

El resumen del artículo es:

En este trabajo, proponemos una parametrización eficiente en comunicación, FedPara, para el aprendizaje federado (FL) con el fin de superar las cargas asociadas a las cargas y descargas frecuentes de modelos. Nuestro método reparametriza los parámetros de peso de las capas utilizando pesos de bajo rango seguidos del producto de Hadamard. En comparación con la parametrización de bajo rango convencional, nuestro método FedPara no está restringido a las limitaciones de bajo rango, y por lo tanto tiene una capacidad mucho mayor. Esta propiedad permite lograr un rendimiento comparable mientras se requieren costos de comunicación de 3 a 10 veces menores que los del modelo con las capas originales, algo que no es posible con los métodos de bajo rango tradicionales. La eficiencia de nuestro método puede mejorarse aún más al combinarlo con otros optimizadores FL eficientes. Además, extendemos nuestro método a una aplicación de FL personalizado, pFedPara, que separa los parámetros en globales y locales. Mostramos que pFedPara supera a los métodos de FL personalizados competidores con más de tres veces menos parámetros.

La descomposición de bajo rango puede afectar el rendimiento porque las actualizaciones de pesos se limitan al espacio de bajo rango, lo que puede restringir la expresividad de un modelo. Sin embargo, no necesariamente se desea usar un rango mayor porque aumenta el número de parámetros entrenables. Para abordar esto, LoHa se aplicó a modelos de difusión, donde la capacidad de generar imágenes diversas es una consideración importante. LoHa también debería funcionar con tipos de modelos generales, pero la compatibilidad con capas de incrustación (embedding) no está implementada actualmente en PEFT.

LoHa utiliza el producto de Hadamard (producto elemento a elemento) en lugar del producto de matrices. ΔW\Delta W se representa mediante cuatro matrices más pequeñas en lugar de dos, como en LoRA, y cada par de estas matrices de bajo rango se combina mediante el producto de Hadamard. Como resultado, ΔW\Delta W puede tener el mismo número de parámetros entrenables, pero un rango y una expresividad mayores.

Cuándo usar LoHa

LoHa es una buena opción cuando:

  • Estás ajustando modelos de generación de imágenes (UNet de Stable Diffusion o codificador de texto), donde se utiliza de forma más amplia.
  • Desea un rango efectivo más alto que LoRA para el mismo número de parámetros entrenables, ya que el producto de Hadamard de dos matrices de bajo rango abarca un subespacio más grande que un solo producto de bajo rango.
  • Desea combinar diferentes métodos de PEFT en tiempo de inferencia usando PeftMixedModel, por ejemplo, LoHa junto con LoKr.

LoHa admite capas lineales y Conv2d. Para tareas que además requieren la adaptación de la capa de embedding, considere usar LoRA en su lugar.

Uso

from diffusers import StableDiffusionPipeline
from peft import LoHaConfig, get_peft_model

config_unet = LoHaConfig(
    r=8,
    alpha=8,
    target_modules=[
        "to_k",
        "to_q",
        "to_v",
        "to_out.0",
        "proj_in",
        "proj_out",
    ],
    rank_dropout=0.0,
    module_dropout=0.0,
    use_effective_conv2d=True,
)

pipeline = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5")
pipeline.unet = get_peft_model(pipeline.unet, config_unet)
pipeline.unet.print_healthcheck()

Resumen de las pruebas de rendimiento

API

LoHaConfig

clase peft.LoHaConfig

< >

( task_type: Optional[Union[str, TaskType]] = Nonepeft_type: Optional[Union[str, PeftType]] = Noneauto_mapping: Optional[dict] = Nonepeft_version: Optional[str] = Nonebase_model_name_or_path: Optional[str] = Nonerevision: Optional[str] = Noneinference_mode: bool = Falserank_pattern: Optional[dict] = <factory>alpha_pattern: Optional[dict] = <factory>r: int = 8alpha: int = 8rank_dropout: float = 0.0module_dropout: float = 0.0use_effective_conv2d: bool = Falsetarget_modules: Optional[Union[list[str], str]] = Noneexclude_modules: Optional[Union[list[str], str]] = Noneinit_weights: bool = Truelayers_to_transform: Optional[Union[list[int], int]] = Nonelayers_pattern: Optional[Union[list[str], str]] = Nonemodules_to_save: Optional[list[str]] = None )

Parámetros

  • r (int) — Rango de LoHa.
  • alpha (int) — El parámetro alpha para el escalado de LoHa.
  • rank_dropout (float) — La probabilidad de dropout para la dimensión de rango durante el entrenamiento.
  • module_dropout (float) — La probabilidad de dropout para desactivar los módulos LoHa durante el entrenamiento.
  • use_effective_conv2d (bool) — Usa la descomposición efectiva de parámetros para Conv2d (y Conv1d) con ksize > 1 (“Proposition 3” del paper de FedPara).
  • target_modules (Optional[Union[List[str], str]]) — Los nombres de los módulos a los que se aplicará el adaptador. Si se especifica, solo se reemplazarán los módulos con los nombres indicados. Al pasar una cadena de caracteres, se realizará una coincidencia mediante expresión regular. Al pasar una lista de cadenas de caracteres, se realizará una coincidencia exacta o se verificará si el nombre del módulo termina con alguna de las cadenas pasadas. Si se especifica como ‘all-linear’, se seleccionarán todos los módulos lineales/Conv1D, excluyendo la capa de salida. Si no se especifica, los módulos se elegirán según la arquitectura del modelo. Si la arquitectura no es conocida, se generará un error; en este caso, debe especificar los módulos objetivo manualmente.
  • exclude_modules (Optional[Union[List[str], str]]) — Los nombres de los módulos a los que no se aplicará el adaptador. Al pasar una cadena de caracteres, se realizará una coincidencia mediante expresión regular. Al pasar una lista de cadenas de caracteres, se realizará una coincidencia exacta o se comprobará si el nombre del módulo termina con alguna de las cadenas de caracteres pasadas.
  • init_weights (bool) — Indica si se debe realizar la inicialización de los pesos del adaptador. El valor predeterminado es True; se desaconseja pasar False.
  • layers_to_transform (Union[List[int], int]) — Los índices de las capas a transformar. Si se pasa una lista de enteros, se aplicará el adaptador a los índices de capa especificados en esta lista. Si se pasa un solo entero, se aplicarán las transformaciones a la capa en este índice.
  • layers_pattern (Optional[Union[List[str], str]]) — El nombre del patrón de capas, utilizado solo si layers_to_transform es diferente de None. Esto debe apuntar al nn.ModuleList del modelo, que a menudo se llama 'layers' o 'h'.
  • rank_pattern (dict) — El mapeo de nombres de capas o expresiones regulares a los rangos que difieren del rango predeterminado especificado por r. Por ejemplo, {'^model.decoder.layers.0.encoder_attn.k_proj': 16}.
  • alpha_pattern (dict) — El mapeo de nombres de capas o expresiones regulares a alfas que son diferentes del alfa predeterminado especificado por alpha. Por ejemplo, {'^model.decoder.layers.0.encoder_attn.k_proj': 16}.
  • modules_to_save (Optional[List[str]]) — Lista de módulos, aparte de las capas de adaptador, que se configurarán como entrenables y se guardarán en el punto de control final.

Esta es la clase de configuración para almacenar la configuración de un LoHaModel.

LoHaModel

clase peft.LoHaModel

< >

( modelpeft_config: Union[PeftConfig, dict[str, PeftConfig]]adapter_name: strlow_cpu_mem_usage: bool = Falsestate_dict: Optional[dict[str, torch.Tensor]] = None ) → torch.nn.Module

Parámetros

  • model (torch.nn.Module) — El modelo al que se adjuntarán las capas del afinador de adaptadores.
  • config (LoHaConfig) — La configuración del modelo LoHa.
  • adapter_name (str) — El nombre del adaptador, por defecto es "default".
  • low_cpu_mem_usage (bool, optional, defaults to False) — Crea pesos de adaptador vacíos en el dispositivo meta. Útil para acelerar el proceso de carga.

Devuelve

torch.nn.Module

El modelo LoHa.

Crea un modelo de producto de Hadamard de bajo rango a partir de un modelo preentrenado. El método se describe parcialmente en https://huggingface.co/papers/2108.06098 La implementación actual toma prestado en gran medida de https://github.com/KohakuBlueleaf/LyCORIS/blob/eb460098187f752a5d66406d3affade6f0a07ece/lycoris/modules/loha.py

Ejemplo:

>>> from diffusers import StableDiffusionPipeline
>>> from peft import LoHaConfig, get_peft_model

>>> config_te = LoHaConfig(
...     r=8,
...     alpha=32,
...     target_modules=["k_proj", "q_proj", "v_proj", "out_proj", "fc1", "fc2"],
...     rank_dropout=0.0,
...     module_dropout=0.0,
...     init_weights=True,
... )
>>> config_unet = LoHaConfig(
...     r=8,
...     alpha=32,
...     target_modules=[
...         "proj_in",
...         "proj_out",
...         "to_k",
...         "to_q",
...         "to_v",
...         "to_out.0",
...         "ff.net.0.proj",
...         "ff.net.2",
...     ],
...     rank_dropout=0.0,
...     module_dropout=0.0,
...     init_weights=True,
...     use_effective_conv2d=True,
... )

>>> model = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5")
>>> model.text_encoder = get_peft_model(model.text_encoder, config_te)
>>> model.unet = get_peft_model(model.unet, config_unet)

Atributos:

  • model (~torch.nn.Module) — El modelo que se va a adaptar.
  • peft_config (LoHaConfig): La configuración del modelo LoHa.
Update on GitHub