Hugging Face's logo

PEFT documentation

DEFT : Fine-Tuning efficace par décomposition pour les modèles de texte vers image

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

and get access to the augmented documentation experience

to get started

DEFT : Fine-Tuning efficace par décomposition pour les modèles de texte vers image

DEFT (Decompositional Efficient Fine-Tuning) est une méthode de fine-tuning efficace en paramètres pour les modèles texte-vers-image. Elle décompose la mise à jour d’une matrice de poids figée W en deux composants entraînables : une projection qui retire un sous-espace de faible rang de W, et une mise à jour de faible rang qui injecte du nouveau contenu dans ce sous-espace. Cette formulation est conçue pour équilibrer l’alignement avec une distribution cible, l’apprentissage de nouveaux concepts à partir de quelques images (personnalisation) et la préservation de la capacité du modèle pré-entraîné à suivre des instructions et à être éditable.

Concrètement, DEFT combine deux composants de faible rang entraînables : (1) une projection sur le complément d'un sous-espace de faible rang engendré par une matrice de faible rang, et (2) une mise à jour de faible rang. La première matrice de faible rang définit le sous-espace, tandis que la seconde permet une adaptation flexible des paramètres au sein de ce sous-espace.

Quand utiliser DEFT : il est le plus adapté pour adapter un modèle à de nouvelles données ou de nouveaux concepts tout en conservant, voire en améliorant, la capacité du modèle de base à suivre des instructions et en limitant au minimum l'oubli de ses capacités précédentes.

Pour chaque couche cible, DEFT apprend une direction de projection P (forme out_features x r) et une matrice d'injection R (forme r x in_features). Le poids effectif est la projection résiduelle

W' = (I - P_proj) @ W + Q_P @ R

Le projecteur P_proj est dérivé de P selon decomposition_method :

  • "relu" (par défaut) : Q_P = P, P_proj = P @ relu(P).T — une projection non orthogonale.
  • "qr" : Q_P = qr(P), P_proj = Q_P @ Q_P.T — une projection orthogonale.

Le terme (I - P_proj) @ W supprime un sous-espace du poids pré-entraîné, tandis que Q_P @ R y injecte du nouveau contenu. Par défaut (init_weights=True), R est initialisé de sorte que la mise à jour soit une identité exacte à l'initialisation (W' == W), de manière à ce que l'entraînement démarre à partir des poids pré-entraînés et apprenne l'injection. La mise à jour est équivalente à un delta additif de faible rang Q_P @ (R - right.T @ W), qui est calculé sans jamais former la matrice de projection out x out et peut être fusionné dans les poids de base pour un déploiement sans inférence.

Définir para=True sélectionne la variante PaRa (Parameter Rank Reduction) : une mise à jour par suppression uniquement W' = (I - P_proj) @ W qui conserve uniquement le terme de suppression de sous-espace et supprime l'injection. Seule la projection P est entraînée (aucune matrice d'injection R), de sorte que l'adaptateur n'est pas une identité à l'initialisation. PaRa a été introduit pour la personnalisation des modèles de diffusion texte-image et est disponible ici comme cas particulier de DEFT.

DEFT est actuellement implémenté pour les couches torch.nn.Linear et Conv1D (par exemple gpt-2, via fan_in_fan_out). L’implémentation originale et les expériences de l’article (Dreambooth, Dreambench Plus, InsDet, VisualCloze, sur Stable Diffusion et un modèle unifié) sont disponibles sur github.com/MAXNORM8650/DEFT.

Si vous utilisez DEFT dans votre travail, veuillez citer l'article :

@article{kumar2026deft,
  title={DEFT: Decompositional Efficient Fine-Tuning for Text-to-Image Models},
  author={Kumar, Komal and Anwer, Rao and Shahbaz Khan, Fahad and Khan, Salman and Laptev, Ivan and Cholakkal, Hisham},
  journal={Advances in Neural Information Processing Systems},
  volume={38},
  pages={102009--102035},
  year={2026}
}

Si vous utilisez la variante PaRa (para=True), veuillez également citer :

@inproceedings{chen2025personalizing,
  title={Para: Personalizing text-to-image diffusion via parameter rank reduction},
  author={Chen, Shangyu and Pan, Zizheng and Cai, Jianfei and Phung, Dinh},
  booktitle={International Conference on Learning Representations},
  year={2025}
}

DeftConfig

classe peft.DeftConfig

< >

( 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 = Falser: int = 8target_modules: Optional[Union[list[str], str]] = Noneexclude_modules: Optional[Union[list[str], str]] = Nonedecomposition_method: Literal['relu', 'qr'] = 'relu'init_scale: float = 1.0alpha: Optional[int] = Nonepara: bool = Falsefan_in_fan_out: bool = Falsedeft_dropout: float = 0.0init_weights: bool = Truelayers_to_transform: Optional[Union[list[int], int]] = Nonelayers_pattern: Optional[Union[list[str], str]] = Nonebias: str = 'none'modules_to_save: Optional[list[str]] = None )

Paramètres

  • r (int) — Le rang de la projection/injection DEFT à travers les couches.
  • target_modules (Optional[Union[List[str], str]]) — Les noms des modules auxquels appliquer l’adaptateur. Si ce paramètre est spécifié, seuls les modules portant les noms indiqués seront remplacés. En cas de chaîne de caractères, une correspondance par expression régulière est effectuée. En cas de liste de chaînes de caractères, une correspondance exacte est réalisée ou il est vérifié si le nom du module se termine par l’une des chaînes fournies. Si la valeur est « all-linear », tous les modules linéaires sont sélectionnés, à l’exception de la couche de sortie. Si ce paramètre n’est pas spécifié, les modules sont choisis en fonction de l’architecture du modèle. Si l’architecture est inconnue, une erreur est levée — dans ce cas, vous devez spécifier manuellement les modules cibles.
  • exclude_modules (Optional[Union[List[str], str]]) — Les noms des modules auxquels l’adaptateur ne doit pas être appliqué. Si une chaîne de caractères est transmise, une correspondance par expression régulière est effectuée. Si une liste de chaînes de caractères est transmise, une correspondance exacte est effectuée ou il est vérifié si le nom du module se termine par l’une des chaînes transmises.
  • decomposition_method (str) — La manière dont le projecteur P_proj est dérivé de P. Soit "relu" (par défaut, P @ relu(P).T non orthogonal) soit "qr" (Q_P @ Q_P.T orthogonal).
  • init_scale (float) — Mise à l'échelle appliquée à l'écart-type utilisé pour initialiser la matrice d'injection R (utilisé uniquement lorsque init_weights=False). Des valeurs plus faibles maintiennent la mise à jour injectée plus proche de zéro à l'initialisation. La valeur par défaut est 1.0.
  • alpha (Optional[int]) — Le facteur d'échelle du terme d'injection, qui est mis à l'échelle par alpha / r (analogue à l'alpha de LoRA). Si None, aucune mise à l'échelle n'est appliquée (facteur 1.0). Le terme de suppression de sous-espace n'est pas affecté.
  • para (bool) — Indique s'il faut utiliser la méthode PaRa : suppression pure du sous-espace (delta = -P_proj @ W) sans terme d'injection. Lorsque True, R n'est pas créé, P est la seule matrice entraînable et l'adaptateur ne peut pas être une identité à l'initialisation. La valeur par défaut est False (DEFT complet).
  • fan_in_fan_out (bool) — Définissez cette valeur sur True si la couche à remplacer stocke les poids sous la forme (fan_in, fan_out). Par exemple, gpt-2 utilise Conv1D qui stocke les poids sous la forme (fan_in, fan_out) et il convient donc de définir cette valeur sur True.
  • deft_dropout (float) — Probabilité de dropout appliquée à l'entrée de la couche. Valeur par défaut : 0.0.
  • init_weights (bool) — Indique s'il faut utiliser l'initialisation par défaut (identité) de DEFT pour les poids de l'adaptateur, afin que l'adaptateur soit un no-op au début de l'entraînement. Ne modifiez pas ce paramètre, sauf si vous savez exactement ce que vous faites. La valeur par défaut est True.
  • layers_to_transform (Union[List[int], int]) — Les indices de couches à transformer. Si une liste d'entiers est transmise, l'adaptateur sera appliqué aux indices de couches spécifiés dans cette liste. Si un seul entier est transmis, les transformations seront appliquées à la couche située à cet index.
  • layers_pattern (Optional[Union[List[str], str]]) — Le nom du motif de couche, utilisé uniquement si layers_to_transform est différent de None. Il doit cibler le nn.ModuleList du modèle, souvent appelé 'layers' ou 'h'.
  • bias (str) — Type de biais pour DEFT. Peut être 'none', 'all' ou 'deft_only'.
  • modules_to_save (List[str]) — Liste des modules, en dehors des couches d’adaptateur, à définir comme entraînables et à enregistrer dans le point de contrôle final.

Ceci est la classe de configuration destinée à stocker la configuration d'un DeftModel.

DEFT (Decompositional Efficient Fine-Tuning) effectue l'injection de connaissances par une mise à jour par projection résiduelle. Pour un poids de base figé W, une direction de projection de faible rang P (forme out_features x r) et une matrice d'injection R (forme r x in_features) sont appris. Le poids adapté est W' = (I - P_proj) @ W + Q_P @ R, où le projecteur P_proj est dérivé de P selon decomposition_method :

  • "relu" (par défaut) : Q_P = P, P_proj = P @ relu(P).T (projection non orthogonale)
  • "qr" : Q_P = qr(P), P_proj = Q_P @ Q_P.T (projection orthogonale)

Par défaut (init_weights=True), R est initialisé de sorte que la mise à jour soit une identité exacte à l’initialisation (le poids adapté est égal à W), de manière à ce que l’entraînement démarre à partir des poids pré-entraînés et apprenne l’injection.

DeftModel

classe peft.DeftModel

< >

( 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

Paramètres

  • model (torch.nn.Module) — Le modèle auquel les couches d’adaptation du tuner seront attachées.
  • config (DeftConfig) — La configuration du modèle DEFT.
  • adapter_name (str) — Le nom de l'adaptateur, par défaut "default".
  • low_cpu_mem_usage (bool, optional, par défaut False) — Crée des poids d'adaptateurs vides sur l'appareil méta. Utile pour accélérer le processus de chargement.

Retourne

torch.nn.Module

Le modèle DEFT.

Crée un modèle DEFT (Decompositional Efficient Fine-Tuning) à partir d'un modèle pré-entraîné.

DEFT fige les poids de base et apprend, pour chaque module cible, une direction de projection de faible rang P et une matrice d'injection R. Le poids effectif devient (I - P_proj) @ W + Q_P @ R, remplaçant un sous-espace de W par du contenu nouvellement injecté (voir DeftConfig pour les variantes disponibles de decomposition_method).

Attributs :

  • model (~torch.nn.Module) — Le modèle à adapter.
  • peft_config (DeftConfig) : La configuration du modèle DEFT.
Update on GitHub

←C3A DeLoRA→