PEFT documentation
LoKr
LoKr

El producto de Kronecker de bajo rango (LoKr) es un método variante de LoRA que aproxima la gran matriz de pesos con dos matrices de bajo rango y las combina mediante el producto de Kronecker. LoKr también proporciona una tercera matriz de bajo rango opcional para ofrecer un mejor control durante el ajuste fino. Al expresar la matriz de actualización de pesos como una descomposición de un producto de Kronecker, creando una matriz por bloques, LoKr es capaz de preservar el rango de la matriz de pesos original. El tamaño de las matrices más pequeñas está determinado por su rango o r. Otra ventaja del producto de Kronecker es que puede vectorizarse apilando las columnas de la matriz. Esto puede acelerar el proceso porque se evita la reconstrucción completa de ∆W.
El resumen del artículo es:
Los modelos generativos de texto a imagen han captado una atención enorme por su capacidad para producir imágenes de alta fidelidad a partir de indicaciones de texto. Entre ellos, Stable Diffusion se distingue como un modelo de código abierto líder en este campo de rápido crecimiento. Sin embargo, las complejidades del ajuste fino de estos modelos plantean múltiples desafíos, desde la integración de nuevas metodologías hasta la evaluación sistemática. Para abordar estos problemas, este artículo presenta LyCORIS Lora beYond Conventional methods, Other Rank adaptation Implementations for Stable diffusion, una biblioteca de código abierto que ofrece una amplia selección de metodologías de ajuste fino para Stable Diffusion. Además, presentamos un marco exhaustivo para la evaluación sistemática de diversas técnicas de ajuste fino. Este marco emplea un conjunto diverso de métricas y profundiza en múltiples facetas del ajuste fino, incluidos los ajustes de hiperparámetros y la evaluación con diferentes tipos de indicaciones a través de varias categorías de conceptos. A través de este enfoque integral, nuestro trabajo proporciona información esencial sobre los efectos sutiles de los parámetros de ajuste fino, cerrando la brecha entre la investigación de vanguardia y la aplicación práctica.
Uso
from peft import LoKrConfig, get_peft_model
config = LoKrConfig(
r=16,
alpha=16,
target_modules=["query", "value"],
module_dropout=0.1,
modules_to_save=["classifier"],
)
model = get_peft_model(model, config)
model.print_healthcheck()Resumen de las pruebas de rendimiento
API
LoKrConfig
clase peft.LoKrConfig
< source >( 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 = Falsedecompose_both: bool = Falsedecompose_factor: int = -1rank_dropout_scale: bool = Falsetarget_modules: Optional[Union[list[str], str]] = Noneexclude_modules: Optional[Union[list[str], str]] = Noneinit_weights: Union[bool, Literal['lycoris']] = 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 LoKr. - alpha (
int) — El parámetro alpha para el escalado de LoKr. - 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 LoKr 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). - decompose_both (
bool) — Realiza la descomposición de rango de la matriz del producto de Kronecker izquierdo. - decompose_factor (
int) — Factor de descomposición del producto de Kronecker. - rank_dropout_scale (‘bool) —
Si se debe escalar el rank dropout durante el entrenamiento, por defecto es
False. - 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 esTrue. Utilice “lycoris” para inicializar los pesos siguiendo el estilo del repositorio LYCORIS. No se recomienda pasarFalse. - 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 silayers_to_transformes diferente deNone. Esto debe apuntar alnn.ModuleListdel 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 porr. 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 poralpha. 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.
Clase de configuración de LoKrModel.
LoKrModel
clase peft.LoKrModel
< source >( 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 (LoKrConfig) — La configuración del modelo LoKr.
- adapter_name (
str) — El nombre del adaptador, por defecto es"default". - low_cpu_mem_usage (
bool,optional, defaults toFalse) — Crea pesos de adaptador vacíos en el dispositivo meta. Útil para acelerar el proceso de carga.
Devuelve
torch.nn.Module
El modelo LoKr.
Crea un modelo de producto de Kronecker de bajo rango a partir de un modelo preentrenado. El método original se describe parcialmente en https://huggingface.co/papers/2108.06098 y en https://huggingface.co/papers/2309.14859 La implementación actual toma en gran medida de https://github.com/KohakuBlueleaf/LyCORIS/blob/eb460098187f752a5d66406d3affade6f0a07ece/lycoris/modules/lokr.py
Ejemplo:
>>> from diffusers import StableDiffusionPipeline
>>> from peft import LoKrConfig, get_peft_model
>>> config_te = LoKrConfig(
... 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 = LoKrConfig(
... 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 (LoKrConfig): La configuración del modelo LoKr.