Skip to content
CAI
Software that uses CAICheck a score

huggingface/peft

59.7

Adequate · 16 November 2026

90.5k

lines of production code

Python

primary language

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add AdaMSS fine-tuning examples with Adaptive Subspace Allocation

Added example scripts and documentation for AdaMSS (Adaptive Matrix Decomposition with Subspace Selection), a parameter-efficient fine-tuning method that uses SVD decomposition and optional Adaptive Subspace Allocation (ASA) to dynamically select the most important subspaces during training. The new files include \glue\_adamss\_asa\_example.py\ for NLU tasks (GLUE benchmark) using the HuggingFace Trainer callback, \glue\_adamss\_asa\_manual\_example.py\ for manual ASA integration in custom training loops, and \image\_classification\_adamss\_asa.py\ for vision tasks (ViT on CIFAR-10, etc.). The \README.md\ provides configuration details, usage instructions, and experimental results showing significant parameter reduction (\~0.07% trainable parameters) while maintaining competitive performance. Also in this area: 1 commit (1 fix) fixing examples; 1 commit adding/updating tests in examples.

_examples/adamss\finetuning · medium confidence · unverified

Add Arrow and GenKnowSub evaluation example for Phi-3 Mini

A new example script (\arrow\_phi3\_mini.py\) is added to the \examples/arrow\_multitask\ directory, demonstrating how to evaluate the Phi-3 Mini model using Arrow modular routing and GenKnowSub (general knowledge subtraction) strategies. The script supports multiple-choice reasoning datasets (such as BoolQ, HellaSwag, ARC, and Winogrande) and allows users to compare base model performance against Arrow and Arrow+GKS approaches, which utilize task-specific LoRA adapters and general-domain knowledge subtraction to improve accuracy.

_examples/arrow\multitask · high confidence

Add Astra LoRA initialization example

The \examples/astra\_finetuning\ directory now includes a complete example for using Astra (Activation-Space Tail-Eigenvector Low-Rank Adaptation) to initialize LoRA adapters. This addition provides \preprocess.py\ and \astra\_finetuning.py\ scripts, along with documentation, that demonstrate how to collect activation covariance matrices from a calibration dataset, perform eigendecomposition to initialize LoRA weights in the task-relevant subspace, and subsequently fine-tune the model. It also covers converting the trained Astra adapter back to a standard LoRA format for deployment.

_examples/astra\finetuning · high confidence

Add BEFT (Bias-Efficient Fine-Tuning) example

Added a new example demonstrating Bias-Efficient Fine-Tuning (BEFT) for language models in low-data regimes. The example script shows how to fine-tune specific bias terms (query, key, or value) using the BeftConfig from PEFT on a financial sentiment analysis dataset, highlighting that fine-tuning value bias terms generally yields higher performance with limited data.

_examples/beft\finetuning · high confidence

Add BOFT ControlNet example utility modules

The examples/boft\_controlnet/utils directory now includes a suite of helper modules to support the Butterfly Factorization (BOFT) ControlNet training example. This includes argument parsing (args\_loader.py), dataset loading and preprocessing (dataset.py), a lightweight ControlNet model implementation (light\_controlnet.py), a custom inference pipeline (pipeline\_controlnet.py), memory tracking utilities (tracemalloc.py), and a modified UNet2DConditionModel (unet\_2d\_condition.py) that supports guided hints for ControlNet conditioning.

_examples/boft\controlnet/utils · high confidence

Add C3A (Circular Convolution Adaptation) adapter

Introduces a new C3A adapter type that applies circular convolution adaptation to linear layers. Users can now configure and apply C3A via \C3AConfig\ (supporting parameters like \block\_size\, \target\_modules\, and \bias\), which replaces target \nn.Linear\ modules with \C3ALinear\ layers that use FFT-based block circular convolution for efficient weight updates. The adapter is registered as a new PEFT method named 'c3a' and supports standard operations like merging, unmerging, and multiple active adapters.

src/peft/tuners/c3a · high confidence

Add CUDA kernel for fast block diagonal operations in BOFT

This change introduces a new CUDA extension (\fbd\) within the BOFT tuner to accelerate fast block diagonal matrix operations. The implementation includes a C++ wrapper (\fbd\_cuda.cpp\) and a CUDA kernel (\fbd\_cuda\_kernel.cu\) that provide optimized forward and backward passes for block diagonal transformations, which are used to improve the performance of the Butterfly Factorization finetuning method.

src/peft/tuners/boft/fbd · high confidence

Add Context-aware Prompt Tuning (CPT) adapter

Users can now apply Context-aware Prompt Tuning (CPT) to causal language models via the \peft\ library. This new feature introduces \CPTConfig\ and \CPTEmbedding\ components that support token type masks, loss weighting with exponential decay, and epsilon-based projection for delta embeddings. The implementation is registered as a standard PEFT method named 'cpt' and is restricted to \TaskType.CAUSAL\_LM\ tasks.

src/peft/tuners/cpt · high confidence

Add CorDA example for context-aware LoRA initialization

The examples/corda\_finetuning directory now includes a complete example for CorDA (Context-Oriented Decomposition Adaptation), an optional initialization method for LoRA adapters that uses task-specific covariance matrices to orient weight decomposition. The example provides scripts for preprocessing (preprocess.py) to build adapters in either Knowledge-Preserved Mode (KPM) or Instruction-Previewed Mode (IPM), and a training script (corda\_finetuning.py) for fine-tuning. It also includes data utilities (datautils.py) for loading calibration datasets and a README with usage instructions and performance comparisons.

_examples/corda\finetuning · high confidence

Add DEFT (Decompositional Efficient Fine-Tuning) example

Added a new example script and documentation for DEFT, a parameter-efficient fine-tuning method that adapts frozen weights by removing a learned rank-r subspace and injecting a low-rank update. The example demonstrates how to configure and train a model using \DeftConfig\ (with options for \relu\ or \qr\ decomposition methods) and provides a command-line interface for fine-tuning causal language models on custom datasets.

_examples/deft\finetuning · high confidence

Add DeLoRA finetuning example

Added a new example script and documentation for DeLoRA (Decoupled Low-Rank Adaptation) finetuning. The \delora\_finetuning.py\ script demonstrates how to use the \DeloraConfig\ to fine-tune models by normalizing low-rank matrices and applying learnable scaling, replacing the standard \lora\_alpha\ with a \delora\_lambda\ parameter to bound the Frobenius norm of weight updates. The accompanying README provides usage instructions, command-line argument details, and best practices for learning rates and lambda values.

(repo-wide) · high confidence

Add FRoD fine-tuning examples for text and image classification

Added new example scripts in \examples/frod\_finetuning/\ that demonstrate how to fine-tune models using the FRoD (Fast Rotational Diagonal) parameterization via PEFT. The \frod\_text\_classification.py\ script shows fine-tuning \google-bert/bert-base-uncased\ on the GLUE SST-2 dataset, while \frod\_image\_classification.py\ demonstrates fine-tuning \openai/clip-vit-base-patch32\ on the Stanford Cars dataset. Both examples configure separate learning rates for FRoD diagonal coefficients, sparse coefficients, and the classification head, and include instructions for running the examples and using local model/dataset mirrors.

_examples/frod\finetuning · high confidence

Add FourierFT adapter support

Introduces FourierFT, a new parameter-efficient fine-tuning method that updates model weights via learnable frequency spectra in the Discrete Fourier Transform domain. Users can now apply this adapter to linear layers by configuring \FourierFTConfig\ (e.g., setting \n\_frequency\ and \scaling\), which replaces target modules with \FourierFTLinear\ layers that inject delta weights derived from the frequency domain. The implementation supports features like \exclude\_modules\, \layers\_to\_transform\, and \n\_frequency\_pattern\ for granular control, and registers the method as 'fourierft' within the PEFT framework.

src/peft/tuners/fourierft · high confidence

Add HRA DreamBooth example with documentation and inference notebook

Added a new example demonstrating how to fine-tune DreamBooth using Householder Reflection Adaptation (HRA) with the stabilityai/stable-diffusion-2-1 model. The change includes a README guide covering environment setup, data preparation, and training arguments (such as \use\_hra\, \hra\_r\, and \hra\_apply\_GS\), along with a Jupyter notebook for generating images with the fine-tuned model.

_examples/hra\dreambooth · high confidence

Add Householder Reflection Adaptation (HRA) method

Introduces a new PEFT tuning method called Householder Reflection Adaptation (HRA). This feature adds the \HRAConfig\ configuration class, \HRAModel\ tuner, and specific layer implementations (\HRALinear\, \HRAConv2d\) that support both linear and convolutional layers. The implementation includes logic for Gram-Schmidt orthogonalization, handles grouped convolution constraints, and registers the method under the name 'hra' for use with supported model architectures.

src/peft/tuners/hra · high confidence

Add KappaTune example demonstrating selective LoRA fine-tuning

Added an example script and documentation in \examples/KappaTune\ that compares standard LoRA, a no-adaptation baseline, and the new KappaTune strategy. The example uses the \find\_kappa\_target\_modules\ helper to select a subset of model parameters (via \top\_p\) for fine-tuning, aiming to reduce catastrophic forgetting on general knowledge (measured via WikiText perplexity) while adapting to a downstream task (GSM8K).

examples/KappaTune · high confidence

Add Lily PEFT finetuning example

Added a new example in \examples/lily\_finetuning\ that demonstrates how to fine-tune models using the Lily (Low-Rank Interconnected Adaptation Across Layers) PEFT method. The entry includes a \lily\_finetuning.py\ script and a \README.md\ explaining the configuration options, such as \stride\_A\ for cross-layer A adapter sharing and \num\_B\ for the global B adapter pool, allowing users to swap \LoraConfig\ for \LilyConfig\ to leverage parameter-efficient cross-layer adaptation.

_examples/lily\finetuning · high confidence

Add LoRA-FA finetuning example with XPU support

Added a new example script and documentation for fine-tuning models using the LoRA-FA (Low-rank Adaptation with Frozen A) method, which reduces memory consumption by freezing the projection down layer. The example demonstrates how to use the \create\_lorafa\_optimizer\ from PEFT with the Hugging Face Trainer, supports quantization via BitsAndBytes, and includes specific handling for Intel XPU accelerators alongside standard CUDA and CPU execution.

_examples/lorafa\finetune · high confidence

Add LoRA-based NER and token classification examples using PEFT

New Jupyter notebooks have been added to the token classification examples directory to demonstrate how to perform Named Entity Recognition (NER) and general token classification using Low-Rank Adaptation (LoRA) via the PEFT library. The NER notebook (\peft\_lora\_ner.ipynb\) provides a complete workflow for fine-tuning a BERT model on the CoNLL-2003 dataset, including data loading, tokenization, and evaluation setup. A second notebook (\peft\_lora\_token\_cls.ipynb\) extends this approach to general token classification tasks. These examples allow users to leverage parameter-efficient fine-tuning techniques for sequence labeling without modifying the base model weights.

_examples/token\classification · high confidence

Add LyCORIS LoHa adapter support for Stable Diffusion models

Introduces the LoHa (Low-Rank Hadamard Product) adapter, a new fine-tuning method based on the LyCORIS implementation, specifically targeting Stable Diffusion and SDXL models. This change adds the \LoHaModel\, \LoHaConfig\, and \LoHaLayer\ classes, enabling users to apply LoHa adapters to \Linear\, \Conv1d\, and \Conv2d\ layers. The implementation supports advanced features such as effective convolution decomposition (as described in the FedPara paper), rank and alpha patterns, and dropout configurations, and registers the method under the name 'loha' within the PEFT framework.

src/peft/tuners/loha · high confidence

Add MiSS adapter support for linear layers

Introduces the MiSS (Householder reflection) adapter, a new parameter-efficient fine-tuning method that can be applied to \torch.nn.Linear\ modules. Users can now configure and attach MiSS adapters via \MissConfig\ and \MissModel\, supporting multiple initialization strategies (\balance\, \bat\, \mini\) and quantization backends, with the adapter registered automatically for discovery by the PEFT framework.

src/peft/tuners/miss · high confidence

Add Orthogonal Subspace Fine-tuning (OSF) continual learning example

Users can now run a new example in \examples/orthogonal\_subspace\_learning\ that demonstrates Orthogonal Subspace Fine-tuning (OSF) for parameter-efficient continual learning. The provided \osf\_continual\_learning.py\ script trains a model sequentially on three tasks (ScienceQA, NumGLUE, and FOMC) while preventing catastrophic forgetting by constraining updates to an orthogonal subspace. The example includes utilities for loading and formatting these specific datasets and allows users to compare OSF performance against a standard full fine-tuning baseline.

_examples/orthogonal\_subspace\learning · high confidence

Add PSOFT fine-tuning example

Added a new example script and documentation for Efficient Orthogonal Fine-Tuning with Principal Subspace Adaptation (PSOFT). The \psoft\_finetuning.py\ script demonstrates how to use the \PsoftConfig\ and \get\_peft\_model\ to fine-tune causal language models (such as LLaMA-3.2-3B) using PSOFT adapters, supporting configuration for rank, scaling factors, SVD initialization methods, and Cayley–Neumann approximations.

_examples/psoft\finetuning · high confidence

Add PVeRA example for generating Monte Carlo confidence intervals

A new example in \examples/pvera\ demonstrates how to use the PVeRA adapter to generate Monte Carlo confidence interval estimations. The provided script and documentation show how to train a model with \sample\_at\_inference=False\ and then load it with \sample\_at\_inference=True\ to run multiple inference passes, enabling users to calculate confidence intervals for predictions.

examples/pvera · high confidence

Add PiSSA finetuning example with SVD-based LoRA initialization

This change introduces a new example demonstrating PiSSA (Principal Singular values and Singular vectors Adaptation), an initialization method for LoRA that uses Singular Value Decomposition (SVD) to initialize adapter matrices for faster convergence and better performance. The example includes a Python script (\pissa\_finetuning.py\) and a preprocessing tool (\preprocess.py\) that allow users to initialize PiSSA adapters from a base model or load pre-processed residual models, supporting both full-precision and 4-bit/8-bit quantization fine-tuning via the TRL \SFTTrainer\. It also provides functionality to convert trained PiSSA adapters into standard LoRA format for easier sharing and inference.

_examples/pissa\finetuning · high confidence

Add Poly Adapter for multitasking scenarios

Introduces the Poly adapter, a new parameter-efficient fine-tuning method that supports multitasking by routing inputs through multiple LoRA 'skills' using a learned router. Users can now configure Poly via \PolyConfig\ (specifying \n\_tasks\, \n\_skills\, and \n\_splits\) and apply it to \torch.nn.Linear\ modules; the adapter automatically injects task-specific mixing weights during forward passes to combine outputs from different skills.

src/peft/tuners/poly · high confidence

Add RandLora finetuning example with quantization and sparsity support

The \examples/randlora\_finetuning\ directory now includes a new finetuning script (\randlora\_finetuning.py\), a Jupyter notebook (\qrandlora\_finetuning.ipynb\), and documentation (\README.md\) for the RandLora parameter-efficient fine-tuning method. Users can now fine-tune models using RandLora, which performs full-rank updates via random bases, or switch to standard LoRA via the \--use\_lora\ flag. The example supports 4-bit quantization (via \--quantize\), sparse or very sparse random bases (via \--sparse\ and \--very\_sparse\), and configurable target modules, rank, and alpha parameters.

_examples/randlora\finetuning · high confidence

Add SHiRA adapter finetuning example

Users can now finetune models using Sparse High Rank Adapters (SHiRA) via the new \examples/shira\_finetuning\ directory. This includes a Python script (\shira\_finetuning.py\) and documentation (\README.md\) that demonstrate how to configure \ShiraConfig\, apply the adapter to a base model, and train using the Hugging Face \transformers\ Trainer API, with support for custom sparse mask functions.

_examples/shira\finetuning · high confidence

Add ShadowPEFT example for parameter-efficient fine-tuning

Added a new example in \examples/shadow\_finetuning\ demonstrating ShadowPEFT, a technique that augments a frozen base model with a small, trainable 'shadow' network. The provided script (\shadow\_finetuning.py\) and documentation show how to configure a shadow backbone (either mirrored from the base model or initialized from a separate pretrained model), perform fine-tuning on the shadow components while keeping the base model frozen, and subsequently extract a standalone shadow model for independent deployment or evaluation.

_examples/shadow\finetuning · high confidence

Add Super-Tuning and Supra hybrid fine-tuning example

Added a new example script and documentation for Super-Tuning, a sparse fine-tuning method that freezes base weights and trains only a small subset of individual scalar entries selected by magnitude. The example demonstrates how to use \SupertuningConfig\ to apply pure sparse support or the 'Supra' hybrid (sparse support plus a LoRA-style low-rank adapter) by setting the rank parameter, allowing users to fine-tune models with significantly fewer trainable parameters than standard LoRA.

_examples/supertuning\finetuning · high confidence

Add UniLoRA tuner to PEFT

Introduces the UniLoRA adapter type, allowing users to apply the Uni-LoRA low-rank adaptation method to supported models. This adds the \UniLoraConfig\ for specifying parameters such as rank, shared vector length, and dropout, along with the \UniLoraLayer\ and \UniLoraModel\ implementations that handle the shared \theta\_d\ vector and index assignment logic. The tuner is registered in the PEFT framework, enabling it to be used via the standard \get\_peft\_model\ interface.

src/peft/tuners/unilora · high confidence

Add VB-LoRA adapter support

Introduces a new VB-LoRA (Variational Bayes Low-Rank Adaptation) tuning method, allowing users to apply this specific adapter type to Hugging Face models via the PEFT library. This includes the \VBLoRAConfig\ for configuring parameters such as rank, vector bank size, and top-K selection, the \VBLoRAModel\ wrapper for injection, and the underlying \VBLoRALayer\ implementation that handles the vector bank and logits logic.

src/peft/tuners/vblora · high confidence

Add WaveFT parameter-efficient fine-tuning method

Introduces WaveFT (Wavelet-based Fine-Tuning), a new adapter method that leverages the sparsity of wavelet transforms to efficiently fine-tune pretrained models. Users can now apply WaveFT to linear layers by configuring parameters such as \n\_frequency\ (number of learnable wavelet coefficients), \wavelet\_family\ (e.g., 'db1', 'sym2'), and \scaling\. The implementation includes a custom \WaveFTConfig\, \WaveFTLayer\, and \WaveFTModel\ that integrate with the existing PEFT framework, supporting features like proportional parameter allocation and specific layer targeting.

src/peft/tuners/waveft · high confidence

Add X-LoRA inference example using mistral.rs

Added a new example script and documentation in the examples/xlora directory demonstrating how to perform inference with X-LoRA models using the mistral.rs engine. The provided Python script shows how to initialize the Runner with X-LoRA specific parameters, including model IDs and ordering files, and execute a chat completion request.

examples/xlora · high confidence

Added LoRA Dreambooth conversion scripts and Colab notebook

The examples/lora\_dreambooth directory now includes utilities to convert LoRA models between the PEFT format and the kohya\_ss format, along with a Colab notebook for running the training. Users can convert kohya\_ss-trained LoRAs to PEFT using \convert\_kohya\_ss\_sd\_lora\_to\_peft.py\ and convert PEFT-trained LoRAs back to kohya\_ss format using \convert\_peft\_sd\_lora\_to\_kohya\_ss.py\, facilitating interoperability between different training ecosystems. The new \colab\_notebook.ipynb\ provides a ready-to-run environment for training LoRA Dreambooth models.

_examples/lora\dreambooth · high confidence

Added MonteCLoRA fine-tuning example for sequence classification

A new example script has been added to the \examples/monteclora\_finetuning\ directory that demonstrates how to fine-tune a sequence classification model (specifically RoBERTa on the GLUE MRPC dataset) using the MonteCLoRA parameter-efficient fine-tuning method. The script integrates the \MontecloraConfig\ and \MonteCLoRATrainerMixin\ from the PEFT library to handle variational loss, allowing users to configure LoRA parameters such as rank, alpha, and the number of Monte Carlo samples via command-line arguments.

_examples/monteclora\finetuning · high confidence

Added example for loading models with DoRA and ephemeral GPU offloading

A new example script, load\_with\_dora.py, has been added to the examples/ephemeral\_gpu\_offloading directory. This script demonstrates how to load a base model and apply a DoRA (Weight-Decomposed Low-Rank Adaptation) adapter using the ephemeral GPU offloading feature. It allows users to benchmark and compare loading times with and without offloading, and includes an option to merge the adapter into the base model and save the result.

_examples/ephemeral\_gpu\offloading · high confidence

Added placeholder directories for image generation results

Empty placeholder directories (\.gitkeep\) have been added to the \method\_comparison/image-gen\ structure, specifically creating \cancelled\_results\, \sample-images/cancelled\_results\, \sample-images/results\, \sample-images/temporary\_results\, and \temporary\_results\. These changes ensure that the directory structure is tracked by version control, likely to support the storage of benchmark output files for cancelled, sample, and temporary image generation tasks.

_method\_comparison/image-gen/cancelled\_results, method\_comparison/image-gen/sample-images, method\_comparison/image-gen/temporary\results · high confidence

Benchmark results for MetaMathQA on Llama-3.2-3B

Added evaluation results for multiple parameter-efficient fine-tuning (PEFT) methods on the MetaMathQA dataset using the Llama-3.2-3B model. The new data covers Adalora, Adamss, AdaptionPrompt (at learning rates 0.0005 and 0.005), BEFT, BOFT, C3A, DEFT (with both standard and parameter-efficient variants), and DeLoRA. Each result file includes detailed training metrics, configuration parameters, and performance accuracy across training steps.

_method\comparison/MetaMathQA/results · high confidence

Initial repository structure and project configuration

The repository is initialized with the core project configuration files, including \setup.py\ (defining the \peft\ package, version 0.21.3.dev0, and dependencies like \torch\, \transformers\, and \accelerate\), \README.md\ (providing documentation and usage examples for Parameter-Efficient Fine-Tuning), and \Makefile\ (defining targets for code quality, styling, and testing). Additionally, development tooling is configured via \.gitignore\, \.pre-commit-config.yaml\ (using ruff), and \SECURITY.md\ (outlining vulnerability reporting procedures).

(repo-wide) · high confidence

Introduce (IA)^3 adapter support for linear, convolutional, and quantized layers

This change adds the (IA)^3 (Infused Adapter by Inhibiting and Amplifying Inner Activations) tuning method to the PEFT library. Users can now apply IA3 adapters to \torch.nn.Linear\, \torch.nn.Conv2d\, \torch.nn.Conv3d\, and \Conv1D\ layers via the new \IA3Config\ and \IA3Model\ classes. The implementation supports feedforward-specific scaling, safe weight merging with NaN validation, and integration with Bitsandbytes 8-bit and 4-bit quantization (\Linear8bitLt\, \Linear4bit\) for memory-efficient training.

src/peft/tuners/ia3 · high confidence

Introduce AdaLoRA adapter support with adaptive rank allocation

Users can now apply the AdaLoRA (Adaptive LoRA) parameter-efficient fine-tuning method to transformer models. This change adds the \AdaLoraConfig\ and \AdaLoraModel\ classes, which implement a rank-allocation strategy that reduces the rank of adapter matrices during training to save memory and compute. The implementation includes support for standard linear layers, 8-bit and 4-bit quantized layers via bitsandbytes, and GPTQ-quantized models. Configuration allows users to set the initial rank (\init\_r\), target rank (\target\_r\), and training schedule parameters (\tinit\, \tfinal\, \total\_step\) to control the rank reduction process.

src/peft/tuners/adalora · high confidence

Introduce AdaMSS parameter-efficient fine-tuning method

Adds the AdaMSS (Adaptive Multi-Subspaces) tuner, a new parameter-efficient fine-tuning method that decomposes weight matrices using SVD and clusters the decomposed space into multiple trainable subspaces. Users can now configure and apply AdaMSS via \AdamssConfig\ (supporting options like \r\, \num\_subspaces\, \subspace\_rank\, and \use\_asa\) to \torch.nn.Linear\ layers. The implementation includes an \AdamssModel\ wrapper, an \AdamssLayer\ for layer-specific logic, and an optional \AdamssAsaCallback\ for HuggingFace \Trainer\ to enable Adaptive Subspace Allocation (ASA), which dynamically prunes less important subspaces during training based on gradient importance scores.

src/peft/tuners/adamss · high confidence

Introduce Adaption Prompt tuner for Llama, Mistral, and GPT-2

Adds the Adaption Prompt adapter method, allowing users to fine-tune Llama, Mistral, and GPT-2 models by injecting trainable prompts into the top attention layers. This new tuner includes model-specific handling for rotary embeddings and query state computation to ensure compatibility across various transformer versions, and registers the method within the PEFT framework for standard usage.

_src/peft/tuners/adaption\prompt · high confidence

Introduce BOFT (Butterfly Orthogonal Finetuning) adapter

Adds a new PEFT tuning method, BOFT, which applies orthogonal transformations via butterfly factorization to specified model layers. This feature introduces \BOFTConfig\ for parameters like block size and butterfly factors, \BOFTLayer\ for the actual transformation logic (including CUDA acceleration for butterfly decomposition), and \BOFTModel\ to integrate the adapter into pretrained models. It supports \Linear\ and \Conv2d\ layers, allows excluding specific modules, and handles bias updates and multiplicative dropout.

src/peft/tuners/boft · high confidence

Introduce DEFT (Decompositional Efficient Fine-Tuning) adapter

Adds the DEFT adapter, a new fine-tuning method that freezes base weights and learns a low-rank projection direction and an injection matrix to replace a subspace of the model's weights. This change introduces the \DeftConfig\, \DeftLayer\, \DeftLinear\, and \DeftModel\ classes, registers the 'deft' method within the PEFT framework, and supports configuration options such as decomposition methods (relu or qr), an optional pure subspace removal mode (PaRa), and layer-specific targeting via \layers\_to\_transform\ and \layers\_pattern\.

src/peft/tuners/deft · high confidence

Introduce DeLoRA adapter for low-rank adaptation

Users can now apply the DeLoRA (Decoupled Low-rank Adaptation) method to fine-tune models. This change adds the \DeloraConfig\, \DeloraLayer\, \DeloraLinear\, and \DeloraModel\ classes to \src/peft/tuners/delora\, registering 'delora' as a new PEFT method. The implementation supports configuration of rank (\r\), a boundary parameter (\delora\_lambda\) to constrain weight changes, target/exclude module patterns, and layer-specific rank or lambda overrides. It is currently limited to \torch.nn.Linear\ layers.

src/peft/tuners/delora · high confidence

Introduce FRoD adapter for sparse rotation-based parameter-efficient fine-tuning

Adds the FRoD (Factorized Rotation Decomposition) tuner, enabling sparse rotation-based adaptation for linear layers. Users can now configure FRoD via \FrodConfig\ (e.g., setting \sparse\_rate\, \regularization\_alpha\, and \target\_modules\) and apply it to supported models. The implementation includes \FrodLayer\ for per-layer sparse rotation matrices and \FrodModel\ for managing shared projection buffers across module categories, with options to offload base weights to CPU to reduce GPU memory usage.

src/peft/tuners/frod · high confidence

Introduce GLoRA adapter support with safe weight merging

Adds the GLoRA (Generalized Low Rank Adapter) tuning method, allowing users to apply low-rank corrections to frozen linear layers with configurable parameterization for weights and biases (lora, vector, constant, or none). The implementation includes a \GloraConfig\ for specifying target modules and initialization, \GloraLayer\ for the adapter logic, and \GloraModel\ for integration with Hugging Face models. A key behavioral fix ensures that \safe\_merge\ correctly unmerges previously merged adapters before re-merging to avoid sequential composition errors on base weights.

src/peft/tuners/glora · high confidence

Introduce HiRA adapter support for linear, convolutional, and embedding layers

Adds the HiRA (Hierarchical Rank-Adaptation) tuning method to PEFT, enabling users to apply low-rank adaptation via Hadamard fusion to Linear, Conv1d/2d/3d, and Embedding layers. The implementation includes the HiraConfig for configuration, HiraLayer and specific layer wrappers (Linear, Conv2d, Conv3d, Embedding) for the adapter logic, and HiraModel for integration with pretrained models. It also provides 8-bit and 4-bit quantized support via bitsandbytes (Linear8bitLt, Linear4bit) and registers HiRA as a mixed-compatible PEFT method.

src/peft/tuners/hira · high confidence

Introduce LayerNorm tuning adapter

Adds a new PEFT method called LayerNorm tuning, allowing users to fine-tune specific LayerNorm layers in a pretrained model by replacing them with tunable copies. This feature includes the \LNTuningConfig\ for specifying target and excluded modules, the \LNTuningModel\ tuner to inject these layers, and the \LNTuningLayer\ implementation which supports single-adapter inference, merging/unmerging, and device preservation. The method is registered in the PEFT framework for use via \get\_peft\_model\.

_src/peft/tuners/ln\tuning · high confidence

Introduce Lily low-rank adapter with layer sharing and router

Adds the Lily PEFT tuner, a new adaptation method that uses a router to combine multiple B adapters and shares A adapters across consecutive layers. Users can configure the adapter rank (r), the A-adapter sharing stride (stride\_A), and the number of B adapters (num\_B) via LilyConfig. The implementation registers the 'lily' method in PEFT, providing LilyModel, LilyLayer, and Linear components that replace target linear modules with the new adapter logic.

src/peft/tuners/lily · high confidence

Introduce LoKr adapter support for Stable Diffusion models

Adds a new LoKr (Low-Rank Kronecker Product) adapter implementation to PEFT, enabling parameter-efficient fine-tuning for Stable Diffusion and SDXL models. This change introduces the \LoKrConfig\, \LoKrModel\, and \LoKrLayer\ classes, which support linear and convolutional layers (Conv1d/Conv2d) with features like effective decomposition for kernels. The adapter is registered as a new PEFT method, allowing users to apply LoKr tuning alongside existing methods like LoRA.

src/peft/tuners/lokr · high confidence

Introduce MetaMathQA method comparison benchmark suite

Adds a new reproducible benchmarking framework in \method\_comparison/MetaMathQA\ to evaluate and compare different PEFT methods on the MetaMathQA and GSM8K datasets. The suite includes a \Makefile\ for automated experiment discovery and execution, a \run.py\ training script with support for \torch.compile\, gradient checkpointing, and mixed precision, and utility modules for data handling (\data.py\) and configuration (\utils.py\). Users can define experiments via \adapter\_config.json\ and \training\_params.json\ files, run them individually or as a suite, and retrieve structured JSON results including training metrics, memory usage, and model checkpoints.

_method\comparison/MetaMathQA · high confidence

Introduce MixedModel to support mixing different adapter types

Users can now apply multiple different adapter types (LoRA, LoHa, LoKr, AdaLoRA, OFT, and SHiRA) to a single model simultaneously by using the new MixedModel tuner. This capability allows for more flexible model tuning strategies where different layers or modules can be adapted using different techniques within the same architecture.

src/peft/tuners/mixed · high confidence

Introduce Multitask Prompt Tuning adapter

Adds a new Multitask Prompt Tuning adapter to PEFT, enabling models to handle multiple tasks via task-specific prompt embeddings. The implementation includes a new \MultitaskPromptTuningConfig\ with initialization strategies (TEXT, RANDOM, AVERAGE\_SOURCE\_TASKS, EXACT\_SOURCE\_TASK, ONLY\_SOURCE\_SHARED) and a \MultitaskPromptEmbedding\ model class that supports loading source state dictionaries from both standard PyTorch and safetensor formats. The adapter is automatically registered under the name 'multitask\_prompt\_tuning' for use with the PEFT library.

_src/peft/tuners/multitask\_prompt\tuning · high confidence

Introduce Orthogonal Finetuning (OFT) adapter

Adds the OFT adapter, a new parameter-efficient fine-tuning method that injects orthogonal rotation matrices into model layers. This feature supports Linear, Conv2d, and Embedding modules, with configuration options for rank, block size, multiplicative dropout, and constrained OFT (COFT). The implementation includes the OFTConfig, OFTLayer, and OFTModel classes, registering 'oft' as a new PEFT method.

src/peft/tuners/oft · high confidence

Introduce Orthogonal Subspace Fine-Tuning (OSF) tuner

Adds a new Orthogonal Subspace Fine-Tuning (OSF) tuner for parameter-efficient continual learning. This feature introduces a new adapter mechanism that decomposes layer weights via SVD into a frozen high-rank subspace and a trainable low-rank subspace, allowing models to learn new tasks while preserving knowledge from previous ones. Users can configure the preserved rank via \effective\_rank\ and apply the tuner to specific linear modules using standard PEFT configuration patterns.

src/peft/tuners/osf · high confidence

Introduce PEANuT adapter for weight-aware parameter-efficient fine-tuning

Users can now apply the PEANuT (PEANut) adapter method to Hugging Face models via the \peft\ library. This new capability adds a \PeanutConfig\ and \PeanutModel\ tuner that implements a weight-aware pathway, where the adapter's delta weight is conditioned on the base layer's weights. The implementation supports configurable rank (\r\), depth (number of hidden encoder/decoder layers), activation functions, and scaling, and registers itself as a new \PeftType.PEANUT\ option alongside existing methods like LoRA.

src/peft/tuners/peanut · high confidence

Introduce PEFT Method Comparison Gradio app with secure filtering

Adds a new \method\_comparison\ module containing a Gradio application (\app.py\) and an embeddable variant (\app\_embed.py\) that visualize Pareto frontiers for comparing PEFT methods across tasks like MetaMathQA and image generation. The app includes a custom input sanitizer (\sanitizer.py\) that parses filter expressions via an Abstract Syntax Tree to prevent arbitrary code execution vulnerabilities associated with standard DataFrame query methods, and includes tests (\test\_sanitizer.py\) verifying this security boundary.

_method\comparison · high confidence

Introduce PEFT Shop Gradio app for browsing and comparing PEFT methods

A new Gradio-based application is available in the \method\_comparison/peft-shop\ directory, allowing users to browse PEFT methods as if in an online store. The app enables filtering by capabilities (such as merging, multi-adapter support, and quantization backends) and by minimum star ratings derived from benchmark results. Users can view benchmark metrics for MetaMathQA and image generation, add methods to a cart to see usage code snippets and feature comparison tables, and access documentation. The app automatically builds its data from the PEFT repository checkout, including extracting method descriptions from official documentation.

_method\comparison/peft-shop · high confidence

Introduce PEFT text generation benchmarking suite

Adds a new benchmarking framework in the \method\_comparison/text\_generation\_benchmark\ directory to measure inference performance, memory usage, and parameter efficiency for Parameter-Efficient Fine-Tuning (PEFT) methods. The suite includes a main runner (\run.py\) and a base model caching script (\run\_base.py\) to establish consistent baselines. It supports configurable model precision (float16, float32, bfloat16), 4-bit and 8-bit quantization via BitsAndBytes, and XPU acceleration. Users can run experiments against short, medium, and long prompt categories, with results logged as structured JSON containing detailed metadata, per-category metrics, and memory logs.

_method\_comparison/text\_generation\benchmark · high confidence

Introduce PSOFT tuner for efficient orthogonal fine-tuning

Adds the PSOFT (Efficient Orthogonal Fine-Tuning with Principal Subspace Adaptation) tuner, allowing users to insert an r\*r orthogonal transformation R between low-rank matrices A and B. This new capability lets you fine-tune models by training only the orthogonal transformation R (and optional magnitude vectors) while keeping A and B frozen, offering a parameter-efficient alternative to existing adapters.

src/peft/tuners/psoft · high confidence

Introduce PVeRA adapter support

Adds the Probabilistic Vector-based Random Matrix Adaptation (PVeRA) tuner to PEFT, enabling users to apply this parameter-efficient fine-tuning method to transformer models. The implementation includes the \PveraConfig\ for tuning parameters such as rank, dropout, and inference sampling, along with \PveraLayer\ and \PveraModel\ classes that manage shared projection matrices (\pvera\_A\/\pvera\_B\) and per-layer trainable vectors. It also provides specific support for 8-bit quantization via \bitsandbytes\ (including merge/unmerge operations) and allows seeding the random generator for reproducible sampling at inference.

src/peft/tuners/pvera · high confidence

Introduce RoAd (2D Rotary Adaptation) as a new PEFT tuning method

Adds the RoAd adapter, a new parameter-efficient fine-tuning technique that applies 2D rotations and learnable scales to linear layer outputs. Users can now configure and apply RoAd via \RoadConfig\ (supporting \road\_1\, \road\_2\, and \road\_4\ variants) and \RoadModel\, with support for both standard PyTorch linear layers and bitsandbytes 8-bit/4-bit quantized layers. The implementation includes the core layer logic, configuration validation, and model integration hooks for mixed-adapter inference.

src/peft/tuners/road · high confidence

Introduce SHiRA sparse high-rank adapter support

Adds a new SHiRA (Sparse High-rank Adapter) tuning method to PEFT, allowing users to apply sparse adapters to linear layers. The implementation includes a \ShiraConfig\ for specifying parameters like rank (\r\) and mask type (defaulting to a random sparse mask), a \ShiraLayer\ that manages sparse weight updates via indices, and a \ShiraModel\ tuner that integrates with the existing PEFT infrastructure. This feature enables parameter-efficient fine-tuning using a sparse approximation strategy distinct from LoRA.

src/peft/tuners/shira · high confidence

Introduce Super-Tuning PEFT method with sparse weight support and optional LoRA hybrid

This change adds the Super-Tuning adapter to the PEFT library, allowing users to fine-tune models by freezing base weights and training only a sparse subset of scalar entries selected by weight magnitude. The implementation includes SupertuningConfig, SupertuningLayer, and SupertuningModel classes, supporting a 'Supra' hybrid mode that combines the sparse support with LoRA A/B parameters when a rank is specified. Users can control sparsity, index persistence (saving precomputed indices vs. reconstructing them at load time), and LoRA-specific settings like alpha and dropout. The adapter is registered as a new PEFT method named 'supertuning'.

src/peft/tuners/supertuning · high confidence

Introduce TinyLoRA parameter-efficient fine-tuning adapter

Adds the TinyLoRA adapter, an extremely parameter-efficient fine-tuning method based on the paper "Learning to Reason in 13 Parameters" (arXiv:2602.04118). This feature replaces the standard LoRA trainable matrix with a tiny trainable vector projected through fixed random tensors, using SVD decomposition of frozen weights. The implementation includes the \TinyLoraConfig\ (supporting options like SVD rank \r\, trainable vector dimension \u\, and weight tying), the \TinyLoraLayer\ (handling the SVD components and projection matrices), and the \TinyLoraModel\ (managing the injection of these layers into supported \nn.Linear\, \nn.Embedding\, and \Conv1D\ modules). The adapter is registered as a new PEFT method named "tinylora".

src/peft/tuners/gralora, src/peft/tuners/randlora, src/peft/tuners/tinylora · high confidence

Introduce Trainable Tokens adapter for efficient embedding updates

A new \TrainableTokens\ adapter is now available, allowing users to train only specific token embeddings (identified by index) rather than the entire embedding matrix. This reduces memory and storage overhead when adding new tokens or fine-tuning existing ones. The implementation includes support for weight tying (syncing tied embeddings like \lm\_head\ with \embed\_tokens\), handles DeepSpeed ZeRO-3 distributed training, and prevents conflicts when merging adapters with overlapping token indices.

_src/peft/tuners/trainable\tokens · high confidence

Introduce VeRA (Vector-based Random Matrix Adaptation) tuner

Adds support for the VeRA parameter-efficient fine-tuning method, which uses shared, random projection matrices (vera\_A and vera\_B) and per-layer trainable scaling vectors (lambda\_b, lambda\_d) to reduce memory overhead compared to LoRA. This change introduces the VeraConfig, VeraLayer, and VeraModel components, registers the 'vera' method within the PEFT framework, and allows users to apply VeRA adapters to linear layers with configurable rank, dropout, and projection saving options.

src/peft/tuners/vera · high confidence

Introduce X-LoRA (Mixture of LoRA Experts) tuner

Adds a new X-LoRA tuning method that dynamically selects and scales LoRA adapters using a learned classifier. This feature introduces \XLoraConfig\ for configuration, \XLoraModel\ as the main tuner class, and specialized layer wrappers (\XLoraLinearLayer\, \XLoraEmbeddingLayer\) that apply dynamic scaling factors to LoRA outputs. The implementation includes a classifier component to predict adapter weights and supports features like top-k sparsity and softmax temperature scaling.

src/peft/tuners/xlora · high confidence

Introduce image generation method comparison benchmark

Adds a new benchmark in \method\_comparison/image-gen\ to compare PEFT methods on a DreamBooth-style image generation task using the FLUX.2-klein-base-4B model. The entry point includes a Makefile for orchestrating experiments, a \run.py\ script for training, and an \evaluate.py\ script for assessing existing checkpoints. Evaluation metrics include DINOv2 cosine similarity and drift, with sample images generated for visual inspection. The benchmark uses a 'cat pillow' dataset by default and supports configurable training parameters via \default\_training\_params.json\ and per-experiment overrides.

_method\comparison/image-gen · high confidence

Introduction of PEFT tuner package structure and core utilities

The \src/peft/tuners\ directory now serves as the central registry for all parameter-efficient fine-tuning methods, exposing a comprehensive set of adapter implementations including LoRA, LoHa, LoKr, BOFT, IA3, and many others via the \\_\init\\_.py\ module. This change introduces foundational infrastructure such as \BufferDict\ for managing model buffers and \LycorisConfig\/\LycorisLayer\ base classes for LyCORIS-style adapters, alongside \tuners\_utils.py\ which provides core logic for adapter injection, target module matching (including specific handling for Mamba architectures), and safe weight merging. Users can now access these diverse tuning methods and configuration classes directly from the \peft.tuners\ namespace.

src/peft/tuners · high confidence

Introduction of Prefix Tuning adapter with zero-initialization support

This change introduces the Prefix Tuning method as a new PEFT adapter, adding the \PrefixEncoder\ model class and \PrefixTuningConfig\ configuration. Users can now apply prefix tuning to their models, with the configuration supporting an \init\_weights\ option set to "zero" to initialize weights such that activations act as a no-op. The implementation includes support for prefix projection via a two-layer MLP and handles loading of flattened prompt embeddings, though loading is restricted to cases where projection is disabled.

_src/peft/tuners/prefix\tuning · high confidence

LoRA tuner restructured into a modular package with new initialization strategies and quantization support

The LoRA tuner implementation has been reorganized into a dedicated \src/peft/tuners/lora\ subpackage, introducing a modular architecture that supports multiple initialization strategies (Arrow, Astra, CorDA, EVA, LoftQ, MonteCLoRA, OLoRA, PiSSA, VeLoRA) and quantization backends (AQLM, AWQ, BitsAndBytes 8-bit/4-bit, EETQ). This change adds new configuration classes for these variants, implements specialized linear layer dispatchers for quantized models, and provides utilities to convert non-LoRA PEFT adapters into LoRA format, enabling broader compatibility with downstream tools like Diffusers and supporting mixed-adapter batch inference.

src/peft/tuners/lora · high confidence

New BD-LoRA finetuning example with multi-GPU serving scripts

Added an example in \examples/bdlora\_finetuning\ that demonstrates Block-Diagonal LoRA (BD-LoRA) finetuning and inference. The notebook (\bdlora\_peft\_demo.ipynb\) shows how to configure \BdLoraConfig\ to constrain LoRA factors as block-diagonal for tensor-parallel serving, while \vllm\_server.bash\ and \chat.py\ provide a ready-to-run setup for launching a vLLM server with block-diagonal sharded LoRAs and querying it.

_examples/bdlora\finetuning · high confidence

New BOFT ControlNet example for controllable generation

Added a new example in \examples/boft\_controlnet\ that demonstrates fine-tuning Stable Diffusion (v1.5 or 2.1) using BOFT (Butterfly Orthogonal Finetuning) for controllable generation via ControlNet. The package includes training (\train\_controlnet.py\), testing (\test\_controlnet.py\), and evaluation (\eval.py\) scripts, along with shell wrappers and documentation. It leverages PEFT's \BOFTConfig\ to inject orthogonal matrices into UNet and text encoder attention blocks, allowing users to fine-tune on datasets like \control-celeba-hq\ for landmark-to-face generation while keeping the base model parameters frozen.

_examples/boft\controlnet · high confidence

New BOFT DreamBooth example with Intel XPU support

This change introduces a new example directory for fine-tuning Stable Diffusion models using BOFT (Orthogonal Finetuning via Butterfly Factorization). The provided training script, inference notebook, and documentation demonstrate how to use the BOFT adapter from PEFT to reduce trainable parameters while maintaining performance. Additionally, the example includes specific setup instructions and code paths for Intel XPU hardware, extending the example's hardware compatibility beyond standard CUDA.

_examples/boft\dreambooth · high confidence

New CPT finetuning example with documentation

Added a new example directory for Context-aware Prompt Tuning (CPT), including a README explaining the method's approach to few-shot learning and a Jupyter notebook demonstrating training and inference setup. This provides users with a concrete reference implementation for applying CPT using the PEFT library.

_examples/cpt\finetuning · high confidence

New DNA Language Model fine-tuning example

Added a new notebook example in the \examples/dna\_language\_models\ directory that demonstrates how to use Parameter-Efficient Fine-Tuning (PEFT) with the SpeciesLM DNA language model. The example shows users how to load the pre-trained model and tokenizer, and apply PEFT techniques to fine-tune the model on a nucleotide benchmark dataset.

_examples/dna\_language\models · high confidence

New DoRA finetuning example with quantization and caching benchmarks

The examples/dora\_finetuning directory now includes a complete guide for fine-tuning models using DoRA (Weight-Decomposed Low-Rank Adaptation). This addition provides a Python script (dora\_finetuning.py) and a Jupyter notebook (QDoRA\_finetuning.ipynb) that demonstrate how to enable DoRA via the \use\_dora\ flag, support for 4-bit quantization (QDoRA), and compatibility with XPU devices. Additionally, a benchmarking script (dora-caching.py) is included to measure the inference performance and memory overhead of DoRA with and without the new caching optimization.

_examples/dora\finetuning · high confidence

New EVA finetuning example with multi-accelerator support

Added a new example directory for Explained Variance Adaptation (EVA), demonstrating how to initialize LoRA adapter weights using data-driven singular value decomposition. The example includes a standard single-GPU script, a multi-accelerator script supporting distributed training across CUDA and XPU devices, and utility classes for tokenizing and collating the MetaMathQA dataset.

_examples/eva\finetuning · high confidence

New FP4 finetuning example using BitsAndBytes and LoRA

Added a new example script for fine-tuning large language models using 4-bit quantization (FP4/NF4) via the BitsAndBytes library combined with LoRA adapters. The script demonstrates loading a model (OPT-350m) with specific quantization configurations, freezing base parameters, applying LoRA, and training on a dataset, supporting both CUDA and Intel XPU devices.

_examples/fp4\finetuning · high confidence

New HiRA fine-tuning example

Added a new example in \examples/hira\_finetuning\ that demonstrates how to fine-tune a causal language model using HiRA adapters. The provided script and README show how to configure HiRA-specific parameters such as the Hadamard modulation rank (\r\) and dropout, mirroring the common LoRA flow with Alpaca-style instruction data.

_examples/hira\finetuning · high confidence

New KaSA fine-tuning example demonstrating spectral-domain adapter training

An example script and documentation have been added for KaSA (Knowledge-aware Singular-value Adaptation), a parameter-efficient fine-tuning method that operates in the spectral domain of base weights. The example shows how to configure \KasaConfig\ within \LoraConfig\ to apply SVD-based truncation and learnable singular-value updates, and demonstrates subclassing \SFTTrainer\ to inject KaSA-specific auxiliary regularizers (L2 penalty on singular values and orthogonal regularization on adapter factors) into the training loss.

_examples/kasa\finetuning · high confidence

New LoRA evaluation notebook using lm-eval-harness

Added a new Jupyter notebook in the examples/evaluation directory that demonstrates how to evaluate a fine-tuned LoRA model on the HellaSwag task using the lm-eval-harness toolkit.

examples/evaluation · high confidence

New LoRA-GA finetuning example with gradient-aligned initialization

Added a new example script and documentation for LoRA-GA (Low-Rank Adaptation with Gradient Approximation) in the \examples/lora\_ga\_finetuning\ directory. This example demonstrates how to use gradient information during the initialization phase to align LoRA adapters with full fine-tuning directions, achieving faster convergence. The script includes a gradient estimation phase, configurable direction and scaling strategies, and specific instructions for saving adapters while handling base weight modifications.

_examples/lora\_ga\finetuning · high confidence

New LoRA-specific optimizers: LoRA-FA, LoRA+, and Riemannian-preconditioned

The \src/peft/optimizers\ module now exposes three new factory functions—\create\_lorafa\_optimizer\, \create\_loraplus\_optimizer\, and \create\_riemannian\_optimizer\—allowing users to fine-tune PEFT models with specialized optimization strategies. LoRA-FA applies a layer-specific scaling factor to the gradient of the B matrix to improve training stability. LoRA+ configures a base optimizer with distinct learning rates for LoRA A and B matrices (and optionally embeddings) based on a user-specified ratio. The Riemannian-preconditioned optimizer wraps a standard optimizer to apply an r×r preconditioner to LoRA A and B gradients on every step, improving convergence for low-rank adapters while leaving other parameters unchanged.

src/peft/optimizers · high confidence

New LoftQ finetuning example directory with DIY and in-place initialization workflows

The \examples/loftq\_finetuning\ directory has been added, providing users with complete workflows for applying LoftQ (LoRA-fine-tuning-aware Quantization). This includes a \quantize\_save\_load.py\ script to generate and save custom 4-bit/8-bit LoftQ initializations for supported models (Llama-2, Mistral, Falcon, BART, T5, etc.), a \train\_gsm8k\_llama.py\ script demonstrating fine-tuning on GSM8K using pre-quantized models, an \int8\_correction.py\ script showing how to mitigate activation quantization errors with LoRA/LoftQ, and a \LoftQ\_weight\_replacement.ipynb\ notebook illustrating how to apply LoftQ initialization in-place to an existing quantized model using \replace\_lora\_weights\_loftq\.

_examples/loftq\finetuning · high confidence

New MiCA fine-tuning example added

Added a new example in \examples/mica\_finetuning\ demonstrating Minor Component Adaptation (MiCA), a parameter-efficient fine-tuning method. The example script and README show how to use the \init\_lora\_weights="mica"\ configuration in \LoraConfig\ to initialize adapters using the singular value decomposition of base weights, training only the \A\ matrix to inject knowledge with a smaller trainable footprint than standard LoRA.

_examples/glora\_finetuning, examples/mica\finetuning · high confidence

New OLoRA finetuning example with orthonormal initialization

Added a new example script and documentation for OLoRA (Orthonormal Low Rank Adaptation), allowing users to finetune models using an initialization strategy that decomposes weights via QR decomposition for faster convergence and more stable training. The example demonstrates how to configure \LoraConfig\ with \init\_lora\_weights="olora"\, supports 4-bit quantization, and includes instructions for running with DDP via Accelerate or converting the resulting model to standard LoRA.

_examples/olora\finetuning · high confidence

New PEFT LoRA example for semantic search and similarity

Added a new Python script and Jupyter notebook example in the feature extraction directory that demonstrates how to fine-tune sentence embedding models using Parameter-Efficient Fine-Tuning (PEFT) with LoRA. The training script provides a complete pipeline for semantic search tasks, including dataset loading, model wrapping for embedding extraction, and optimization with Accelerate, while the accompanying notebook illustrates the inference workflow for computing semantic similarity between queries and products.

_examples/feature\extraction · high confidence

New PEFT and DeepSpeed example notebooks and scripts for causal language modeling

Added new example files in the causal language modeling directory: a DeepSpeed ZeRO-3 CPU offload configuration file, and Jupyter notebooks demonstrating PEFT techniques including LayerNorm (LN) tuning, prefix tuning, and prompt tuning, alongside a Python script for LoRA training with DeepSpeed offload and a notebook for training LoRA with additional tokenizer tokens.

_examples/causal\_language\modeling · high confidence

New PEFT examples for conditional generation tasks

Added new example scripts and notebooks in the conditional generation directory demonstrating how to fine-tune sequence-to-sequence models using various Parameter-Efficient Fine-Tuning (PEFT) methods, including AdaLoRA, IA3, LoRA, Prefix Tuning, Prompt Tuning, and Multitask Prompt Tuning. The collection also includes distributed training examples using DeepSpeed ZeRO-3 offload and FSDP, along with a configuration file for DeepSpeed CPU offloading.

_examples/conditional\generation · high confidence

New Poly Adapter example for sequence-to-sequence models

Added a new notebook example (\peft\_poly\_seq2seq\_with\_generate.ipynb\) demonstrating how to use the Poly Adapter with sequence-to-sequence models like \google/flan-t5-xl\. The example shows how to initialize a \PolyModel\ with specific configurations for rank, number of tasks, skills, and splits, and how to integrate it with the Hugging Face \Seq2SeqTrainer\ for multi-task learning.

examples/poly · high confidence

New QALoRA GPTQ finetuning example

Added a new example script and documentation for fine-tuning models using Quantization-Aware LoRA (QALoRA) with GPTQ-quantized base models. The \qalora\_gptq\_finetuning.py\ script enables users to load, cache, and quantize models on-the-fly, then apply QALoRA adapters to reduce memory usage while preserving performance. The accompanying README provides usage instructions, command-line examples, and explains the implementation details regarding merging with quantized models.

_examples/qalora\finetuning · high confidence

New RoAd finetuning example for 2D Rotary Adaptation

Added a new example script and documentation for fine-tuning models using RoAd (2D Rotary Adaptation). The \road\_finetuning.py\ script demonstrates how to apply the \RoadConfig\ via PEFT to support efficient parameter-efficient fine-tuning, including options for 4-bit quantization, device placement, and pushing results to the Hugging Face Hub.

_examples/road\finetuning · high confidence

New Supervised Fine-Tuning (SFT) example with PEFT and distributed training support

This change introduces a new \examples/sft\ directory providing a complete, modular example for Supervised Fine-Tuning using PEFT (LoRA/QLoRA). It includes a refactored \train.py\ script that leverages \SFTConfig\ and \SFTTrainer\ from TRL, supporting 4-bit and 8-bit quantization via BitsAndBytes, Flash Attention 2, and Unsloth optimizations. The example is designed for various distributed setups, with dedicated launch scripts (\run\_peft.sh\, \run\_peft\_multigpu.sh\, \run\_peft\_deepspeed.sh\, \run\_peft\_fsdp.sh\, etc.) and corresponding Accelerate configuration files for DeepSpeed ZeRO-3 and FSDP. It also includes specific support for GPT-Q quantized models with FSDP and handles edge cases like embedding resizing errors in QLoRA+FSDP scenarios.

examples/sft · high confidence

New UniLoRA finetuning example

Added a new example script and documentation for UniLoRA, a parameter-efficient fine-tuning method that shares a compact trainable vector bank across low-rank adapter weights. The \unilora\_finetuning.py\ script demonstrates how to configure and train a model using \UniLoraConfig\ from PEFT, supporting options for base model selection, data paths, and adapter parameters like rank and dropout. The accompanying README provides a quick-start guide and instructions for fine-tuning on datasets like MetaMathQA.

_examples/unilora\finetuning · high confidence

New aLoRA finetuning example with invocation token support

Added a new example script and documentation for Activated LoRA (aLoRA), a technique that selectively activates adapter weights only after a specific invocation sequence to enable KV cache reuse. The \alora\_finetuning.py\ script allows users to fine-tune models using the \alora\_invocation\_tokens\ configuration, supporting both CUDA and XPU devices, and includes an inference function to demonstrate the adapter's behavior.

_examples/alora\finetuning · high confidence

New cartridge self-study distillation example with XPU support

The \examples/cartridge\_self\_study\ directory now provides a complete workflow for training CARTRIDGE adapters via self-study context distillation. This includes scripts to synthesize training data (\synthesize.py\, \arxiv\_synthesize.py\) and train the adapter (\train\_distill.py\, \arxiv\_train.py\), along with documentation. The training scripts have been updated to support Intel XPU devices alongside CUDA and MPS, allowing users to run the distillation process on XPU hardware.

_examples/cartridge\_self\study · high confidence

New example for LoRA fine-tuning ESM2 with Transformer Engine

Adds a new example in \examples/lora\_finetuning\_transformer\_engine\ that demonstrates fine-tuning the ESM2 protein language model using Low-Rank Adaptation (LoRA) via PEFT, accelerated by NVIDIA Transformer Engine. The entry includes the training script (\lora\_finetuning\_te.py\), a Dockerfile for a self-contained environment based on \nvcr.io/nvidia/pytorch:26.01-py3\, and documentation explaining how to run the example with synthetic data or the Porter6 dataset.

_examples/lora\_finetuning\_transformer\engine · high confidence

New example for fine-tuning custom models with LoRA

Added a new notebook and README in the \examples/multilayer\_perceptron\ directory that demonstrates how to apply Low-Rank Adaptation (LoRA) via PEFT to a custom multilayer perceptron model rather than a standard transformers model. This example illustrates that PEFT supports fine-tuning arbitrary model architectures for classification tasks, provided the layers being adapted are supported.

_examples/multilayer\perceptron · high confidence

New image classification examples using LoRA and PEFT

Added two new Jupyter notebooks demonstrating how to fine-tune image classification models using Low-Rank Adaptation (LoRA) via the PEFT library. The first notebook covers fine-tuning a Vision Transformer model, highlighting that only a small fraction of parameters are trained. The second notebook demonstrates fine-tuning a PoolFormer model from the timm library, showing that PEFT supports Conv2D layers for image models.

_examples/image\classification · high confidence

New int8 training examples for BLIP-2, Whisper, and OPT models

Added new example scripts and notebooks in the \examples/int8\_training\ directory demonstrating how to fine-tune large models using 8-bit quantization with \bitsandbytes\ and parameter-efficient fine-tuning (PEFT). The new additions include a Python script and configuration for fine-tuning BLIP-2 with LoRA, a Python script and shell script for fine-tuning Whisper-large-v2 with AdaLora, and Jupyter notebooks for fine-tuning OPT and Whisper-large-v2 using LoRA. These examples provide users with ready-to-run templates for memory-efficient training of vision-language and speech-to-text models on consumer hardware.

_examples/int8\training · high confidence

New multi-adapter examples for LoRA merging, inference, and Diffusers integration

Added three new Jupyter notebooks in the multi-adapter examples directory: Lora\_Merging.ipynb demonstrates merging multiple LoRA adapters using weighted combinations and density-based techniques (ties, linear, dare\_linear) with support for Intel XPU devices; PEFT\_Multi\_LoRA\_Inference.ipynb shows how to load and switch between multiple adapters on a base model (Llama-2) for multi-lingual inference with 8-bit quantization; multi\_adapter\_weighted\_inference\_diffusers.ipynb illustrates applying PEFT adapter merging methods to image generation models using Diffusers' UNet2DConditionModel with Stable Diffusion XL.

_examples/multi\_adapter\examples · high confidence

New p-tuning and prompt-tuning tuners with configurable initialization

This change introduces two new parameter-efficient fine-tuning methods to the library: p-tuning and prompt-tuning. The p-tuning implementation adds a \PromptEncoder\ that generates virtual token embeddings using either an MLP or LSTM reparameterization, configurable via \PromptEncoderConfig\. The prompt-tuning implementation adds a \PromptEmbedding\ module that initializes virtual tokens using one of three strategies: random (\RANDOM\), text-based initialization from a provided string and tokenizer (\TEXT\), or sampling from the model's existing vocabulary (\SAMPLE\_VOCAB\). Both methods are registered as new PEFT methods, allowing users to apply these specific tuning techniques to their models.

_src/peft/tuners/prompt\tuning · high confidence

New semantic segmentation example using LoRA and PEFT

Added a new Jupyter notebook example in the \examples/semantic\_segmentation\ directory that demonstrates how to fine-tune a SegFormer model for semantic segmentation using Low-Rank Adaptation (LoRA) from the PEFT library. The example shows how to achieve this with only 14% of the original trainable parameters by training low-rank update matrices on attention blocks, and includes steps for installing dependencies, authenticating with Hugging Face, loading the SceneParse150 dataset, and preparing data for training.

_examples/semantic\segmentation · high confidence

New sequence classification examples for C3A, FourierFT, IA3, VB-LoRA, VeRA, and torchao

The examples/sequence\_classification directory now includes new Jupyter notebooks demonstrating how to fine-tune models using C3A, FourierFT, IA3, VB-LoRA, and VeRA adapters, as well as examples showing how to use PyTorch AO (torchao) for 8-bit weight-only and dynamic activation quantization with LoRA.

_examples/sequence\classification · high confidence

New utility scripts for documentation coverage, CI cache management, and PEFT method capabilities

This update introduces several new scripts to the \scripts/\ directory. \check\_doc\coverage.py\ allows users to verify that public API objects are documented by scanning markdown files for references to \\\all\\_\ exports, supporting both static analysis and runtime inspection for packages like \transformers\. \ci\_clean\_cache.py\ provides a utility to identify and optionally delete Hugging Face Hub cache revisions older than a specified age. \generate\_method\_capabilities.py\ creates a machine-readable JSON matrix detailing which features (e.g., quantization backends, layer types) each PEFT method supports. Additionally, \convert-bone-to-miss.py\ enables conversion of Bone checkpoints to the MiSS format, \evaluate-lora-conversion.py\ facilitates benchmarking PEFT models converted to LoRA, and \train\_memory.py\ helps estimate memory consumption during training.

scripts · high confidence

PEFT library initialization and core API structure

The \src/peft\ package is initialized with version 0.21.3.dev0, exposing the full public API including \AutoPeftModel\ classes for automatic task-based model loading, \PeftModel\ wrappers, and a comprehensive registry of tuners (such as LoRA, IA3, and AdaptionPrompt) and their configurations. The library introduces a security-focused \import\_allowlist\ mechanism in \AutoPeftModel.from\_pretrained\ to restrict dynamic imports of base model libraries to a safe set (e.g., \transformers\, \diffusers\), and provides helper utilities for signature updates, adapter scaling, and model status inspection.

src/peft · high confidence

Support for LoHa and LoKr adapters in Dreambooth and conversion tools

The Dreambooth training example now supports LyCORIS LoHa and LoKr adapter types in addition to standard LoRA, allowing users to train with these alternative low-rank adaptation methods for Stable Diffusion and SDXL models. A new conversion script has been added to transform kohya\_ss-style LoRA, LoHa, and LoKr adapter checkpoints into the PEFT format, enabling interoperability between different training ecosystems. Additionally, an example demonstrates loading LoRA adapters into FP8 quantized FLUX models on Intel Gaudi (HPU) hardware using Intel Neural Compressor.

_examples/stable\diffusion · high confidence

Architecture

PEFT library refactored into a new modular structure

The PEFT library has been reorganized into a new modular structure, moving utility code into a dedicated \src/peft/utils\ package. This change introduces a centralized \\_\init\\_.py\ that exposes core constants, error classes, and wrapper utilities, while splitting specific functionalities into separate modules such as \hotswap.py\ for adapter switching, \incremental\_pca.py\ for SVD operations, \integrations.py\ for distributed training support, and \loftq\_utils.py\ for quantization helpers. This refactoring improves code organization and maintainability without altering the public API surface.

src/peft/utils · high confidence

Behavioural changes

1 commit (0 fixes) modifying examples, method\_comparison

A change to existing behaviour in examples, method\_comparison — 1 commit, 12 files: “Chore transformers renames gradient checkpointing to activation checkpointing (\#4114)” (refs \#4114). Also in this area: New DEFT DreamBooth fine-tuning example.

_examples/deft\dreambooth · low confidence · unverified

1 commit (0 fixes) modifying examples/paca\_finetuning, src/peft/tuners/paca

A change to existing behaviour in examples/paca\_finetuning, src/peft/tuners/paca — 1 commit, 7 files: “FEAT Add PaCA (Partial Connection Adaptation) (\#3927)” (refs \#3927).

_examples/paca\finetuning · medium confidence · unverified

3 commits (1 fix) modifying src/peft

A change to existing behaviour in src/peft — 3 commits (1 fix), 27 files: “ENH Support LoRA conversion for multiplicative PEFT methods (\#3360)”; “FIX prepare\_model\_for\_kbit\_training defaults to use\_reentrant False (\#4146)”; “FEAT Add helper function to create a dummy LoRA config to hotswap (\#3739)” (refs \#3360, \#4146, \#3739). Also in this area: 1 commit (0 fixes) modifying examples/paca\_finetuning, src/peft/tuners/paca.

src/peft/tuners/paca · medium confidence · unverified

5 commits (2 fixes) modifying src/peft/tuners/shadow

A change to existing behaviour in src/peft/tuners/shadow — 5 commits (2 fixs), 5 files: “FIX Restore fallback trainability after deleting active adapter (\#3743)”; “FIX ShadowPEFT last-token pooling with left padding (\#3629)”; “ENH Pin UTF-8 encoding when reading/writing adapter config (\#3771)”; and 2 more (refs \#3743, \#3629, \#3771, \#3354, \#4087).

src/peft/tuners/shadow · medium confidence · unverified

Apple Silicon GPU acceleration and XPU support added to OFT DreamBooth example

The OFT DreamBooth example now supports Apple Silicon GPU acceleration and Intel XPU, allowing users to run inference and training on these specific hardware platforms. Additionally, the example has been updated to use the current \dtype\ argument instead of the deprecated \torch\_dtype\, and the deprecated \Repository\ class has been replaced with the recommended alternative to ensure compatibility with recent library versions.

_examples/oft\dreambooth · high confidence · unverified

Benchmark results for new PEFT methods on FLUX.2-klein

Added image generation benchmark results for multiple PEFT methods (including AdaLoRA, AdaMSS, BEFT, BOFT, C3A, DEFT, DeLoRA, and DoRA) trained on the FLUX.2-klein-base-4B model using the internal cat-image-dataset. These JSON files document training configurations, hyperparameters, and performance metrics (such as DINO similarity and training time) to support method comparison.

_method\comparison/image-gen/results · high confidence

Test coverage

Added distributed training tests for LoRA adapters and tensor parallelism; Added regression test suite for PEFT model outputs and state dict serialization; New PEFT test suite documentation and expanded test coverage.

Dependencies

Standardize example dependencies and configure project tooling

This change introduces explicit \requirements.txt\ files for all example directories (such as \sft\, \lora\_dreambooth\, \boft\_controlnet\, and \method\_comparison\), ensuring each example installs the precise library versions needed to run correctly. It also adds a \pyproject.toml\ to the project root to centralize configuration for \ruff\ (set to version 0.16.4) and \pytest\, while establishing a root \requirements.txt\ for the core library's development dependencies.

(dependencies) · high confidence

Housekeeping

Added placeholder directories for MetaMathQA evaluation results

Created empty \.gitkeep\ files in the \method\_comparison/MetaMathQA/cancelled\_results\ and \method\_comparison/MetaMathQA/temporary\_results\ directories. This ensures these folders are tracked by version control, providing a stable location for storing evaluation results for cancelled and temporary test cases.

_method\_comparison/MetaMathQA/cancelled\_results, method\_comparison/MetaMathQA/temporary\results · high confidence

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 63.0 → 59.6 (-3.4)
  • Rubric changed (rubric-2026.11.2 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 65.8 → 58.7 (-7.1)
  • Architecture 88.2 → 90.4 (+2.2)
  • Maturity 57.9 → 61.5 (+3.6)
  • Readiness 67.0 → 55.6 (-11.4)
  • Security 65.6 → 67.2 (+1.6)

Resolved (62)

  • Change coupling: layer.py ↔ layer.py (src/peft/tuners/adalora/layer.py)
  • Change-coupling hub: model.py → model.py, model.py, model.py (src/peft/tuners/oft/model.py)
  • Conv2d.update_layer (cognitive 16) (src/peft/tuners/oft/layer.py)
  • Duplicated block (10–12 lines × 3) (examples/boft_dreambooth/utils/args_loader.py)
  • Duplicated block (11 lines × 2) (src/peft/tuners/adalora/config.py)
  • Duplicated block (11 lines × 2) (src/peft/tuners/oft/layer.py)
  • Duplicated block (12–13 lines × 2) (src/peft/tuners/adalora/layer.py)
  • Duplicated block (13–17 lines × 2) (examples/boft_dreambooth/train_dreambooth.py)
  • Duplicated block (13–17 lines × 2) (src/peft/tuners/lora/conversion.py)
  • Duplicated block (15 lines × 2) (src/peft/tuners/lora/conversion.py)
  • Duplicated block (15–19 lines × 2) (examples/sequence_classification/peft_lora_relation_extraction.py)
  • Duplicated block (19 lines × 2) (src/peft/tuners/pvera/layer.py)
  • Duplicated block (20 lines × 2) (src/peft/tuners/pvera/model.py)
  • Duplicated block (21 lines × 2) (examples/int8_training/peft_adalora_whisper_large_training.py)
  • Duplicated block (21 lines × 2) (src/peft/tuners/oft/layer.py)
  • Duplicated block (21 lines × 4) (examples/int8_training/peft_adalora_whisper_large_training.py)
  • Duplicated block (23 lines × 4) (examples/deft_dreambooth/train_dreambooth.py)
  • Duplicated block (24 lines × 2) (examples/int8_training/peft_adalora_whisper_large_training.py)
  • Duplicated block (28 lines × 2) (examples/astra_finetuning/datautils.py)
  • Duplicated block (2–11 lines × 6) (examples/lora_finetuning_transformer_engine/lora_finetuning_te.py)
  • …and 42 more

New (227)

  • Duplicated block (10 lines × 2) (src/peft/tuners/lora/layer.py)
  • Duplicated block (11–14 lines × 2) (src/peft/tuners/lora/conversion.py)
  • Duplicated block (12 lines × 2) (src/peft/tuners/boft/layer.py)
  • Duplicated block (17 lines × 3) (src/peft/tuners/oft/layer.py)
  • Duplicated block (18 lines × 2) (src/peft/tuners/oft/layer.py)
  • Duplicated block (42 lines × 2) (src/peft/tuners/lora/layer.py)
  • Duplicated block (5 lines × 2) (src/peft/tuners/ia3/layer.py)
  • Duplicated block (8–10 lines × 10) (src/peft/tuners/adalora/config.py)
  • Duplicated block (8–11 lines × 2) (src/peft/tuners/oft/layer.py)
  • Duplicated block (9–10 lines × 7) (src/peft/tuners/fourierft/config.py)
  • Duplicated block (9–12 lines × 5) (src/peft/tuners/fourierft/config.py)
  • Edited copies of one member (3 members, 12+ corresponding lines) (src/peft/tuners/glora/model.py)
  • Edited copies of one member (3 members, 13+ corresponding lines) (src/peft/tuners/adamss/model.py)
  • Edited copies of one member (3 members, 13+ corresponding lines) (src/peft/tuners/beft/layer.py)
  • Edited copies of one member (3 members, 13+ corresponding lines) (src/peft/tuners/pvera/config.py)
  • Edited copies of one member (3 members, 16+ corresponding lines) (src/peft/tuners/lora/aqlm.py)
  • Edited copies of one member (3 members, 17+ corresponding lines) (src/peft/peft_model.py)
  • Edited copies of one member (3 members, 18+ corresponding lines) (src/peft/tuners/randlora/layer.py)
  • Edited copies of one member (3 members, 19+ corresponding lines) (src/peft/utils/merge_utils.py)
  • Edited copies of one member (3 members, 20+ corresponding lines) (src/peft/tuners/deft/layer.py)
  • …and 207 more

Changes since last survey

  • 31 commits — 20 feature/other, 11 fixes

By area

  • src/peft — 18 commits
  • (root) — 3 commits
  • docs/source — 3 commits
  • tests/test_decoder_models.py — 2 commits
  • .ai/AGENTS.md — 1 commit
  • scripts/stale.py — 1 commit
  • tests/test_custom_models.py — 1 commit
  • tests/test_parallelism.py — 1 commit
  • tests/test_target_parameters.py — 1 commit

Notable commits

  • fix: DOC Fix docstring examples of LoHa, LoKr, OFT, MiSS and HRA (#4091)
  • fix: FIX AdaLoRA Conv2d with groups and padding_mode (#4084)
  • fix: FIX BOFT and OFT Conv2d layers (#4157)
  • fix: FIX Empty adapter state dict with nested FSDP or checkpoint_wrapper (#4108)
  • fix: FIX Gather FSDP2 adapter DTensors when saving (#4065)
  • fix: FIX Make FSDP2 merges reach the sharded parameters (#4077)
  • fix: FIX Validate the requested adapter configuration during hotswap (#3865)
  • fix: FIX all-linear on Qwen2 MoE correctly targets experts (#4154)
  • fix: FIX prepare_model_for_kbit_training defaults to use_reentrant False (#4146)
  • fix: Fix infer_device() fallback on torch.accelerator backends (e.g. torch_tpu) (#4099)
  • fix: save_and_load: fix false-positive warning with LoRA bias (#3817)
  • change: AGENTS.md: PR description should fit git history (#4034)
  • change: Bump dev version to 0.21.4.dev (#4167)
  • change: CHORE Stale bot exempts post-v1 label (#4179)
  • change: CI: Better slow test report (#4136)
  • change: DOC Add use cases and limitations to Llama-Adapter page (#4103)
  • change: DOC Update README quickstart text to match Qwen example (#4145)
  • change: ENH Add replace_lora_weights_pissa for 4-bit models (#4135)
  • change: ENH Add strict_adapter_check for model loading (#3832)
  • change: ENH Consistently reject layers_to_transform with str target_modules (#4087)
  • …and 11 more

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

huggingface/peft was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 16 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 28719900254e5bba0099a834bdca5c8c085f1527 — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.84+preprod-d645ca9bbedd.