Stage Harbor release files 72501-73000

tasks/tasksmith-c488fc138ba1/environment/source/examples/stable_diffusion/train_dreambooth.py

@@ -0,0 +1,1275 @@
+import argparse
+import gc
+import hashlib
+import itertools
+import logging
+import math
+import os
+import threading
+import warnings
+from pathlib import Path
+from typing import Union
+
+import datasets
+import diffusers
+import numpy as np
+import psutil
+import torch
+import torch.nn.functional as F
+import torch.utils.checkpoint
+import transformers
+from accelerate import Accelerator
+from accelerate.logging import get_logger
+from accelerate.utils import set_seed
+from diffusers import (
+    AutoencoderKL,
+    DDPMScheduler,
+    DiffusionPipeline,
+    DPMSolverMultistepScheduler,
+    UNet2DConditionModel,
+)
+from diffusers.optimization import get_scheduler
+from diffusers.utils import check_min_version
+from diffusers.utils.import_utils import is_xformers_available
+from huggingface_hub import HfApi
+from PIL import Image
+from torch.utils.data import Dataset
+from torchvision import transforms
+from tqdm.auto import tqdm
+from transformers import AutoTokenizer, PretrainedConfig
+
+from peft import LoHaConfig, LoKrConfig, LoraConfig, get_peft_model
+
+
+# Will error if the minimal version of diffusers is not installed. Remove at your own risks.
+check_min_version("0.10.0.dev0")
+
+logger = get_logger(__name__)
+
+UNET_TARGET_MODULES = [
+    "to_q",
+    "to_k",
+    "to_v",
+    "proj",
+    "proj_in",
+    "proj_out",
+    "conv",
+    "conv1",
+    "conv2",
+    "conv_shortcut",
+    "to_out.0",
+    "time_emb_proj",
+    "ff.net.2",
+]
+
+TEXT_ENCODER_TARGET_MODULES = ["fc1", "fc2", "q_proj", "k_proj", "v_proj", "out_proj"]
+
+
+def import_model_class_from_model_name_or_path(pretrained_model_name_or_path: str, revision: str):
+    text_encoder_config = PretrainedConfig.from_pretrained(
+        pretrained_model_name_or_path,
+        subfolder="text_encoder",
+        revision=revision,
+    )
+    model_class = text_encoder_config.architectures[0]
+
+    if model_class == "CLIPTextModel":
+        from transformers import CLIPTextModel
+
+        return CLIPTextModel
+    elif model_class == "RobertaSeriesModelWithTransformation":
+        from diffusers.pipelines.alt_diffusion.modeling_roberta_series import RobertaSeriesModelWithTransformation
+
+        return RobertaSeriesModelWithTransformation
+    else:
+        raise ValueError(f"{model_class} is not supported.")
+
+
+def create_unet_adapter_config(args: argparse.Namespace) -> Union[LoraConfig, LoHaConfig, LoKrConfig]:
+    if args.adapter == "full":
+        raise ValueError("Cannot create unet adapter config for full parameter")
+
+    if args.adapter == "lora":
+        config = LoraConfig(
+            r=args.unet_r,
+            lora_alpha=args.unet_alpha,
+            target_modules=UNET_TARGET_MODULES,
+            lora_dropout=args.unet_dropout,
+            bias=args.unet_bias,
+            init_lora_weights=True,
+        )
+    elif args.adapter == "loha":
+        config = LoHaConfig(
+            r=args.unet_r,
+            alpha=args.unet_alpha,
+            target_modules=UNET_TARGET_MODULES,
+            rank_dropout=args.unet_rank_dropout,
+            module_dropout=args.unet_module_dropout,
+            use_effective_conv2d=args.unet_use_effective_conv2d,
+            init_weights=True,
+        )
+    elif args.adapter == "lokr":
+        config = LoKrConfig(
+            r=args.unet_r,
+            alpha=args.unet_alpha,
+            target_modules=UNET_TARGET_MODULES,
+            rank_dropout=args.unet_rank_dropout,
+            module_dropout=args.unet_module_dropout,
+            use_effective_conv2d=args.unet_use_effective_conv2d,
+            decompose_both=args.unet_decompose_both,
+            decompose_factor=args.unet_decompose_factor,
+            init_weights=True,
+        )
+    else:
+        raise ValueError(f"Unknown adapter type {args.adapter}")
+
+    return config
+
+
+def create_text_encoder_adapter_config(args: argparse.Namespace) -> Union[LoraConfig, LoHaConfig, LoKrConfig]:
+    if args.adapter == "full":
+        raise ValueError("Cannot create text_encoder adapter config for full parameter")
+
+    if args.adapter == "lora":
+        config = LoraConfig(
+            r=args.te_r,
+            lora_alpha=args.te_alpha,
+            target_modules=TEXT_ENCODER_TARGET_MODULES,
+            lora_dropout=args.te_dropout,
+            bias=args.te_bias,
+            init_lora_weights=True,
+        )
+    elif args.adapter == "loha":
+        config = LoHaConfig(
+            r=args.te_r,
+            alpha=args.te_alpha,
+            target_modules=TEXT_ENCODER_TARGET_MODULES,
+            rank_dropout=args.te_rank_dropout,
+            module_dropout=args.te_module_dropout,
+            init_weights=True,
+        )
+    elif args.adapter == "lokr":
+        config = LoKrConfig(
+            r=args.te_r,
+            alpha=args.te_alpha,
+            target_modules=TEXT_ENCODER_TARGET_MODULES,
+            rank_dropout=args.te_rank_dropout,
+            module_dropout=args.te_module_dropout,
+            decompose_both=args.te_decompose_both,
+            decompose_factor=args.te_decompose_factor,
+            init_weights=True,
+        )
+    else:
+        raise ValueError(f"Unknown adapter type {args.adapter}")
+
+    return config
+
+
+def parse_args(input_args=None):
+    parser = argparse.ArgumentParser(description="Simple example of a training script.")
+    parser.add_argument(
+        "--pretrained_model_name_or_path",
+        type=str,
+        default=None,
+        required=True,
+        help="Path to pretrained model or model identifier from huggingface.co/models.",
+    )
+    parser.add_argument(
+        "--revision",
+        type=str,
+        default=None,
+        required=False,
+        help="Revision of pretrained model identifier from huggingface.co/models.",
+    )
+    parser.add_argument(
+        "--tokenizer_name",
+        type=str,
+        default=None,
+        help="Pretrained tokenizer name or path if not the same as model_name",
+    )
+    parser.add_argument(
+        "--instance_data_dir",
+        type=str,
+        default=None,
+        required=True,
+        help="A folder containing the training data of instance images.",
+    )
+    parser.add_argument(
+        "--class_data_dir",
+        type=str,
+        default=None,
+        required=False,
+        help="A folder containing the training data of class images.",
+    )
+    parser.add_argument(
+        "--instance_prompt",
+        type=str,
+        default=None,
+        required=True,
+        help="The prompt with identifier specifying the instance",
+    )
+    parser.add_argument(
+        "--class_prompt",
+        type=str,
+        default=None,
+        help="The prompt to specify images in the same class as provided instance images.",
+    )
+    parser.add_argument(
+        "--with_prior_preservation",
+        default=False,
+        action="store_true",
+        help="Flag to add prior preservation loss.",
+    )
+    parser.add_argument("--prior_loss_weight", type=float, default=1.0, help="The weight of prior preservation loss.")
+    parser.add_argument(
+        "--num_class_images",
+        type=int,
+        default=100,
+        help=(
+            "Minimal class images for prior preservation loss. If there are not enough images already present in"
+            " class_data_dir, additional images will be sampled with class_prompt."
+        ),
+    )
+    parser.add_argument(
+        "--validation_prompt",
+        type=str,
+        default=None,
+        help="A prompt that is used during validation to verify that the model is learning.",
+    )
+    parser.add_argument(
+        "--num_validation_images",
+        type=int,
+        default=4,
+        help="Number of images that should be generated during validation with `validation_prompt`.",
+    )
+    parser.add_argument(
+        "--validation_steps",
+        type=int,
+        default=100,
+        help=(
+            "Run dreambooth validation every X steps. Dreambooth validation consists of running the prompt"
+            " `args.validation_prompt` multiple times: `args.num_validation_images`."
+        ),
+    )
+    parser.add_argument(
+        "--output_dir",
+        type=str,
+        default="text-inversion-model",
+        help="The output directory where the model predictions and checkpoints will be written.",
+    )
+    parser.add_argument("--seed", type=int, default=None, help="A seed for reproducible training.")
+    parser.add_argument(
+        "--resolution",
+        type=int,
+        default=512,
+        help=(
+            "The resolution for input images, all the images in the train/validation dataset will be resized to this"
+            " resolution"
+        ),
+    )
+    parser.add_argument(
+        "--center_crop", action="store_true", help="Whether to center crop images before resizing to resolution"
+    )
+    parser.add_argument("--train_text_encoder", action="store_true", help="Whether to train the text encoder")
+
+    parser.add_argument(
+        "--train_batch_size", type=int, default=4, help="Batch size (per device) for the training dataloader."
+    )
+    parser.add_argument(
+        "--sample_batch_size", type=int, default=4, help="Batch size (per device) for sampling images."
+    )
+    parser.add_argument("--num_train_epochs", type=int, default=1)
+    parser.add_argument(
+        "--max_train_steps",
+        type=int,
+        default=None,
+        help="Total number of training steps to perform.  If provided, overrides num_train_epochs.",
+    )
+    parser.add_argument(
+        "--checkpointing_steps",
+        type=int,
+        default=500,
+        help=(
+            "Save a checkpoint of the training state every X updates. These checkpoints can be used both as final"
+            " checkpoints in case they are better than the last checkpoint, and are also suitable for resuming"
+            " training using `--resume_from_checkpoint`."
+        ),
+    )
+    parser.add_argument(
+        "--resume_from_checkpoint",
+        type=str,
+        default=None,
+        help=(
+            "Whether training should be resumed from a previous checkpoint. Use a path saved by"
+            ' `--checkpointing_steps`, or `"latest"` to automatically select the last available checkpoint.'
+        ),
+    )
+    parser.add_argument(
+        "--gradient_accumulation_steps",
+        type=int,
+        default=1,
+        help="Number of updates steps to accumulate before performing a backward/update pass.",
+    )
+    parser.add_argument(
+        "--gradient_checkpointing",
+        action="store_true",
+        help="Whether or not to use gradient checkpointing to save memory at the expense of slower backward pass.",
+    )
+    parser.add_argument(
+        "--learning_rate",
+        type=float,
+        default=5e-6,
+        help="Initial learning rate (after the potential warmup period) to use.",
+    )
+    parser.add_argument(
+        "--scale_lr",
+        action="store_true",
+        default=False,
+        help="Scale the learning rate by the number of accelerators, gradient accumulation steps, and batch size.",
+    )
+    parser.add_argument(
+        "--lr_scheduler",
+        type=str,
+        default="constant",
+        help=(
+            'The scheduler type to use. Choose between ["linear", "cosine", "cosine_with_restarts", "polynomial",'
+            ' "constant", "constant_with_warmup"]'
+        ),
+    )
+    parser.add_argument(
+        "--lr_warmup_steps", type=int, default=500, help="Number of steps for the warmup in the lr scheduler."
+    )
+    parser.add_argument(
+        "--lr_num_cycles",
+        type=int,
+        default=1,
+        help="Number of hard resets of the lr in cosine_with_restarts scheduler.",
+    )
+    parser.add_argument("--lr_power", type=float, default=1.0, help="Power factor of the polynomial scheduler.")
+    parser.add_argument(
+        "--use_8bit_adam", action="store_true", help="Whether or not to use 8-bit Adam from bitsandbytes."
+    )
+    parser.add_argument("--adam_beta1", type=float, default=0.9, help="The beta1 parameter for the Adam optimizer.")
+    parser.add_argument("--adam_beta2", type=float, default=0.999, help="The beta2 parameter for the Adam optimizer.")
+    parser.add_argument("--adam_weight_decay", type=float, default=1e-2, help="Weight decay to use.")
+    parser.add_argument("--adam_epsilon", type=float, default=1e-08, help="Epsilon value for the Adam optimizer")
+    parser.add_argument("--max_grad_norm", default=1.0, type=float, help="Max gradient norm.")
+    parser.add_argument("--push_to_hub", action="store_true", help="Whether or not to push the model to the Hub.")
+    parser.add_argument("--hub_token", type=str, default=None, help="The token to use to push to the Model Hub.")
+    parser.add_argument(
+        "--hub_model_id",
+        type=str,
+        default=None,
+        help="The name of the repository to keep in sync with the local `output_dir`.",
+    )
+    parser.add_argument(
+        "--logging_dir",
+        type=str,
+        default="logs",
+        help=(
+            "[TensorBoard](https://www.tensorflow.org/tensorboard) log directory. Will default to"
+            " *output_dir/runs/**CURRENT_DATETIME_HOSTNAME***."
+        ),
+    )
+    parser.add_argument(
+        "--allow_tf32",
+        action="store_true",
+        help=(
+            "Whether or not to allow TF32 on Ampere GPUs. Can be used to speed up training. For more information, see"
+            " https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices"
+        ),
+    )
+    parser.add_argument(
+        "--report_to",
+        type=str,
+        default="tensorboard",
+        help=(
+            'The integration to report the results and logs to. Supported platforms are `"tensorboard"`'
+            ' (default), `"wandb"` and `"comet_ml"`. Use `"all"` to report to all integrations.'
+        ),
+    )
+    parser.add_argument(
+        "--wandb_key",
+        type=str,
+        default=None,
+        help=("If report to option is set to wandb, api-key for wandb used for login to wandb "),
+    )
+    parser.add_argument(
+        "--wandb_project_name",
+        type=str,
+        default=None,
+        help=("If report to option is set to wandb, project name in wandb for log tracking  "),
+    )
+    parser.add_argument(
+        "--mixed_precision",
+        type=str,
+        default=None,
+        choices=["no", "fp16", "bf16"],
+        help=(
+            "Whether to use mixed precision. Choose between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >="
+            " 1.10. and an Nvidia Ampere GPU or Intel XPU.  Default to the value of accelerate config of the current system or the"
+            " flag passed with the `accelerate.launch` command. Use this argument to override the accelerate config."
+        ),
+    )
+    parser.add_argument(
+        "--prior_generation_precision",
+        type=str,
+        default=None,
+        choices=["no", "fp32", "fp16", "bf16"],
+        help=(
+            "Choose prior generation precision between fp32, fp16 and bf16 (bfloat16). Bf16 requires PyTorch >="
+            " 1.10. and an Nvidia Ampere GPU or Intel XPU. Default to fp16 if an accelerator is available else fp32."
+        ),
+    )
+    parser.add_argument("--local_rank", type=int, default=-1, help="For distributed training: local_rank")
+    parser.add_argument(
+        "--enable_xformers_memory_efficient_attention", action="store_true", help="Whether or not to use xformers."
+    )
+
+    # Adapter arguments
+    subparsers = parser.add_subparsers(dest="adapter")
+
+    # Dummy subparser to train whole model
+    subparsers.add_parser("full", help="Train full model without adapters")
+
+    # LoRA adapter
+    lora = subparsers.add_parser("lora", help="Use LoRA adapter")
+    lora.add_argument("--unet_r", type=int, default=8, help="LoRA rank for unet")
+    lora.add_argument("--unet_alpha", type=int, default=8, help="LoRA alpha for unet")
+    lora.add_argument("--unet_dropout", type=float, default=0.0, help="LoRA dropout probability for unet")
+    lora.add_argument(
+        "--unet_bias",
+        type=str,
+        default="none",
+        help="Bias type for LoRA. Can be 'none', 'all' or 'lora_only'",
+    )
+    lora.add_argument(
+        "--te_r", type=int, default=8, help="LoRA rank for text_encoder, only used if `train_text_encoder` is True"
+    )
+    lora.add_argument(
+        "--te_alpha",
+        type=int,
+        default=8,
+        help="LoRA alpha for text_encoder, only used if `train_text_encoder` is True",
+    )
+    lora.add_argument(
+        "--te_dropout",
+        type=float,
+        default=0.0,
+        help="LoRA dropout probability for text_encoder, only used if `train_text_encoder` is True",
+    )
+    lora.add_argument(
+        "--te_bias",
+        type=str,
+        default="none",
+        help="Bias type for LoRA. Can be 'none', 'all' or 'lora_only', only used if `train_text_encoder` is True",
+    )
+
+    # LoHa adapter
+    loha = subparsers.add_parser("loha", help="Use LoHa adapter")
+    loha.add_argument("--unet_r", type=int, default=8, help="LoHa rank for unet")
+    loha.add_argument("--unet_alpha", type=int, default=8, help="LoHa alpha for unet")
+    loha.add_argument("--unet_rank_dropout", type=float, default=0.0, help="LoHa rank_dropout probability for unet")
+    loha.add_argument(
+        "--unet_module_dropout", type=float, default=0.0, help="LoHa module_dropout probability for unet"
+    )
+    loha.add_argument(
+        "--unet_use_effective_conv2d",
+        action="store_true",
+        help="Use parameter effective decomposition in unet for Conv2d 3x3 with ksize > 1",
+    )
+    loha.add_argument(
+        "--te_r", type=int, default=8, help="LoHa rank for text_encoder, only used if `train_text_encoder` is True"
+    )
+    loha.add_argument(
+        "--te_alpha",
+        type=int,
+        default=8,
+        help="LoHa alpha for text_encoder, only used if `train_text_encoder` is True",
+    )
+    loha.add_argument(
+        "--te_rank_dropout",
+        type=float,
+        default=0.0,
+        help="LoHa rank_dropout probability for text_encoder, only used if `train_text_encoder` is True",
+    )
+    loha.add_argument(
+        "--te_module_dropout",
+        type=float,
+        default=0.0,
+        help="LoHa module_dropout probability for text_encoder, only used if `train_text_encoder` is True",
+    )
+
+    # LoKr adapter
+    lokr = subparsers.add_parser("lokr", help="Use LoKr adapter")
+    lokr.add_argument("--unet_r", type=int, default=8, help="LoKr rank for unet")
+    lokr.add_argument("--unet_alpha", type=int, default=8, help="LoKr alpha for unet")
+    lokr.add_argument("--unet_rank_dropout", type=float, default=0.0, help="LoKr rank_dropout probability for unet")
+    lokr.add_argument(
+        "--unet_module_dropout", type=float, default=0.0, help="LoKr module_dropout probability for unet"
+    )
+    lokr.add_argument(
+        "--unet_use_effective_conv2d",
+        action="store_true",
+        help="Use parameter effective decomposition in unet for Conv2d 3x3 with ksize > 1",
+    )
+    lokr.add_argument(
+        "--unet_decompose_both", action="store_true", help="Decompose left matrix in kronecker product for unet"
+    )
+    lokr.add_argument(
+        "--unet_decompose_factor", type=int, default=-1, help="Decompose factor in kronecker product for unet"
+    )
+    lokr.add_argument(
+        "--te_r", type=int, default=8, help="LoKr rank for text_encoder, only used if `train_text_encoder` is True"
+    )
+    lokr.add_argument(
+        "--te_alpha",
+        type=int,
+        default=8,
+        help="LoKr alpha for text_encoder, only used if `train_text_encoder` is True",
+    )
+    lokr.add_argument(
+        "--te_rank_dropout",
+        type=float,
+        default=0.0,
+        help="LoKr rank_dropout probability for text_encoder, only used if `train_text_encoder` is True",
+    )
+    lokr.add_argument(
+        "--te_module_dropout",
+        type=float,
+        default=0.0,
+        help="LoKr module_dropout probability for text_encoder, only used if `train_text_encoder` is True",
+    )
+    lokr.add_argument(
+        "--te_decompose_both",
+        action="store_true",
+        help="Decompose left matrix in kronecker product for text_encoder, only used if `train_text_encoder` is True",
+    )
+    lokr.add_argument(
+        "--te_decompose_factor",
+        type=int,
+        default=-1,
+        help="Decompose factor in kronecker product for text_encoder, only used if `train_text_encoder` is True",
+    )
+
+    if input_args is not None:
+        args = parser.parse_args(input_args)
+    else:
+        args = parser.parse_args()
+
+    env_local_rank = int(os.environ.get("LOCAL_RANK", "-1"))
+    if env_local_rank != -1 and env_local_rank != args.local_rank:
+        args.local_rank = env_local_rank
+
+    if args.with_prior_preservation:
+        if args.class_data_dir is None:
+            raise ValueError("You must specify a data directory for class images.")
+        if args.class_prompt is None:
+            raise ValueError("You must specify prompt for class images.")
+    else:
+        # logger is not available yet
+        if args.class_data_dir is not None:
+            warnings.warn("You need not use --class_data_dir without --with_prior_preservation.")
+        if args.class_prompt is not None:
+            warnings.warn("You need not use --class_prompt without --with_prior_preservation.")
+
+    return args
+
+
+# Converting Bytes to Megabytes
+def b2mb(x):
+    return int(x / 2**20)
+
+
+# This context manager is used to track the peak memory usage of the process
+class TorchTracemalloc:
+    def __enter__(self):
+        gc.collect()
+        self.device_type = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+        self.device_module = getattr(torch, self.device_type, torch.cuda)
+        self.device_module.empty_cache()
+        self.device_module.reset_peak_memory_stats()  # reset the peak gauge to zero
+        self.begin = self.device_module.memory_allocated()
+        self.process = psutil.Process()
+
+        self.cpu_begin = self.cpu_mem_used()
+        self.peak_monitoring = True
+        peak_monitor_thread = threading.Thread(target=self.peak_monitor_func)
+        peak_monitor_thread.daemon = True
+        peak_monitor_thread.start()
+        return self
+
+    def cpu_mem_used(self):
+        """get resident set size memory for the current process"""
+        return self.process.memory_info().rss
+
+    def peak_monitor_func(self):
+        self.cpu_peak = -1
+
+        while True:
+            self.cpu_peak = max(self.cpu_mem_used(), self.cpu_peak)
+
+            # can't sleep or will not catch the peak right (this comment is here on purpose)
+            # time.sleep(0.001) # 1msec
+
+            if not self.peak_monitoring:
+                break
+
+    def __exit__(self, *exc):
+        self.peak_monitoring = False
+
+        gc.collect()
+        self.device_module.empty_cache()
+        self.end = self.device_module.memory_allocated()
+        self.peak = self.device_module.max_memory_allocated()
+        self.used = b2mb(self.end - self.begin)
+        self.peaked = b2mb(self.peak - self.begin)
+
+        self.cpu_end = self.cpu_mem_used()
+        self.cpu_used = b2mb(self.cpu_end - self.cpu_begin)
+        self.cpu_peaked = b2mb(self.cpu_peak - self.cpu_begin)
+        # print(f"delta used/peak {self.used:4d}/{self.peaked:4d}")
+
+
+class DreamBoothDataset(Dataset):
+    """
+    A dataset to prepare the instance and class images with the prompts for fine-tuning the model.
+    It pre-processes the images and the tokenizes prompts.
+    """
+
+    def __init__(
+        self,
+        instance_data_root,
+        instance_prompt,
+        tokenizer,
+        class_data_root=None,
+        class_prompt=None,
+        size=512,
+        center_crop=False,
+    ):
+        self.size = size
+        self.center_crop = center_crop
+        self.tokenizer = tokenizer
+
+        self.instance_data_root = Path(instance_data_root)
+        if not self.instance_data_root.exists():
+            raise ValueError("Instance images root doesn't exists.")
+
+        self.instance_images_path = list(Path(instance_data_root).iterdir())
+        self.num_instance_images = len(self.instance_images_path)
+        self.instance_prompt = instance_prompt
+        self._length = self.num_instance_images
+
+        if class_data_root is not None:
+            self.class_data_root = Path(class_data_root)
+            self.class_data_root.mkdir(parents=True, exist_ok=True)
+            self.class_images_path = list(self.class_data_root.iterdir())
+            self.num_class_images = len(self.class_images_path)
+            self._length = max(self.num_class_images, self.num_instance_images)
+            self.class_prompt = class_prompt
+        else:
+            self.class_data_root = None
+
+        self.image_transforms = transforms.Compose(
+            [
+                transforms.Resize(size, interpolation=transforms.InterpolationMode.BILINEAR),
+                transforms.CenterCrop(size) if center_crop else transforms.RandomCrop(size),
+                transforms.ToTensor(),
+                transforms.Normalize([0.5], [0.5]),
+            ]
+        )
+
+    def __len__(self):
+        return self._length
+
+    def __getitem__(self, index):
+        example = {}
+        instance_image = Image.open(self.instance_images_path[index % self.num_instance_images])
+        if instance_image.mode != "RGB":
+            instance_image = instance_image.convert("RGB")
+        example["instance_images"] = self.image_transforms(instance_image)
+        example["instance_prompt_ids"] = self.tokenizer(
+            self.instance_prompt,
+            truncation=True,
+            padding="max_length",
+            max_length=self.tokenizer.model_max_length,
+            return_tensors="pt",
+        ).input_ids
+
+        if self.class_data_root:
+            class_image = Image.open(self.class_images_path[index % self.num_class_images])
+            if class_image.mode != "RGB":
+                class_image = class_image.convert("RGB")
+            example["class_images"] = self.image_transforms(class_image)
+            example["class_prompt_ids"] = self.tokenizer(
+                self.class_prompt,
+                truncation=True,
+                padding="max_length",
+                max_length=self.tokenizer.model_max_length,
+                return_tensors="pt",
+            ).input_ids
+
+        return example
+
+
+def collate_fn(examples, with_prior_preservation=False):
+    input_ids = [example["instance_prompt_ids"] for example in examples]
+    pixel_values = [example["instance_images"] for example in examples]
+
+    # Concat class and instance examples for prior preservation.
+    # We do this to avoid doing two forward passes.
+    if with_prior_preservation:
+        input_ids += [example["class_prompt_ids"] for example in examples]
+        pixel_values += [example["class_images"] for example in examples]
+
+    pixel_values = torch.stack(pixel_values)
+    pixel_values = pixel_values.to(memory_format=torch.contiguous_format).float()
+
+    input_ids = torch.cat(input_ids, dim=0)
+
+    batch = {
+        "input_ids": input_ids,
+        "pixel_values": pixel_values,
+    }
+    return batch
+
+
+class PromptDataset(Dataset):
+    "A simple dataset to prepare the prompts to generate class images on multiple accelerators."
+
+    def __init__(self, prompt, num_samples):
+        self.prompt = prompt
+        self.num_samples = num_samples
+
+    def __len__(self):
+        return self.num_samples
+
+    def __getitem__(self, index):
+        example = {}
+        example["prompt"] = self.prompt
+        example["index"] = index
+        return example
+
+
+def main(args):
+    logging_dir = Path(args.output_dir, args.logging_dir)
+
+    accelerator = Accelerator(
+        gradient_accumulation_steps=args.gradient_accumulation_steps,
+        mixed_precision=args.mixed_precision,
+        log_with=args.report_to,
+        project_dir=logging_dir,
+    )
+    if args.report_to == "wandb":
+        import wandb
+
+        wandb.login(key=args.wandb_key)
+        wandb.init(project=args.wandb_project_name)
+    # Currently, it's not possible to do gradient accumulation when training two models with accelerate.accumulate
+    # This will be enabled soon in accelerate. For now, we don't allow gradient accumulation when training two models.
+    # TODO (patil-suraj): Remove this check when gradient accumulation with two models is enabled in accelerate.
+    if args.train_text_encoder and args.gradient_accumulation_steps > 1 and accelerator.num_processes > 1:
+        raise ValueError(
+            "Gradient accumulation is not supported when training the text encoder in distributed training. "
+            "Please set gradient_accumulation_steps to 1. This feature will be supported in the future."
+        )
+
+    # Make one log on every process with the configuration for debugging.
+    logging.basicConfig(
+        format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
+        datefmt="%m/%d/%Y %H:%M:%S",
+        level=logging.INFO,
+    )
+    logger.info(accelerator.state, main_process_only=False)
+    if accelerator.is_local_main_process:
+        datasets.utils.logging.set_verbosity_warning()
+        transformers.utils.logging.set_verbosity_warning()
+        diffusers.utils.logging.set_verbosity_info()
+    else:
+        datasets.utils.logging.set_verbosity_error()
+        transformers.utils.logging.set_verbosity_error()
+        diffusers.utils.logging.set_verbosity_error()
+
+    # If passed along, set the training seed now.
+    if args.seed is not None:
+        set_seed(args.seed)
+
+    # Generate class images if prior preservation is enabled.
+    if args.with_prior_preservation:
+        class_images_dir = Path(args.class_data_dir)
+        if not class_images_dir.exists():
+            class_images_dir.mkdir(parents=True)
+        cur_class_images = len(list(class_images_dir.iterdir()))
+
+        if cur_class_images < args.num_class_images:
+            dtype = torch.float16 if accelerator.device.type in ["cuda", "xpu"] else torch.float32
+            if args.prior_generation_precision == "fp32":
+                dtype = torch.float32
+            elif args.prior_generation_precision == "fp16":
+                dtype = torch.float16
+            elif args.prior_generation_precision == "bf16":
+                dtype = torch.bfloat16
+            pipeline = DiffusionPipeline.from_pretrained(
+                args.pretrained_model_name_or_path,
+                dtype=dtype,
+                safety_checker=None,
+                revision=args.revision,
+            )
+            pipeline.set_progress_bar_config(disable=True)
+
+            num_new_images = args.num_class_images - cur_class_images
+            logger.info(f"Number of class images to sample: {num_new_images}.")
+
+            sample_dataset = PromptDataset(args.class_prompt, num_new_images)
+            sample_dataloader = torch.utils.data.DataLoader(sample_dataset, batch_size=args.sample_batch_size)
+
+            sample_dataloader = accelerator.prepare(sample_dataloader)
+            pipeline.to(accelerator.device)
+
+            for example in tqdm(
+                sample_dataloader, desc="Generating class images", disable=not accelerator.is_local_main_process
+            ):
+                images = pipeline(example["prompt"]).images
+
+                for i, image in enumerate(images):
+                    hash_image = hashlib.sha1(image.tobytes()).hexdigest()
+                    image_filename = class_images_dir / f"{example['index'][i] + cur_class_images}-{hash_image}.jpg"
+                    image.save(image_filename)
+
+            del pipeline
+
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+            elif torch.xpu.is_available():
+                torch.xpu.empty_cache()
+
+    # Handle the repository creation
+    if accelerator.is_main_process:
+        if args.push_to_hub:
+            api = HfApi(token=args.hub_token)
+
+            # Create repo (repo_name from args or inferred)
+            repo_name = args.hub_model_id
+            if repo_name is None:
+                repo_name = Path(args.output_dir).absolute().name
+            repo_id = api.create_repo(repo_name, exist_ok=True).repo_id
+
+            with open(os.path.join(args.output_dir, ".gitignore"), "w+") as gitignore:
+                if "step_*" not in gitignore:
+                    gitignore.write("step_*\n")
+                if "epoch_*" not in gitignore:
+                    gitignore.write("epoch_*\n")
+        elif args.output_dir is not None:
+            os.makedirs(args.output_dir, exist_ok=True)
+
+    # Load the tokenizer
+    if args.tokenizer_name:
+        tokenizer = AutoTokenizer.from_pretrained(args.tokenizer_name, revision=args.revision, use_fast=False)
+    elif args.pretrained_model_name_or_path:
+        tokenizer = AutoTokenizer.from_pretrained(
+            args.pretrained_model_name_or_path,
+            subfolder="tokenizer",
+            revision=args.revision,
+            use_fast=False,
+        )
+
+    # import correct text encoder class
+    text_encoder_cls = import_model_class_from_model_name_or_path(args.pretrained_model_name_or_path, args.revision)
+
+    # Load scheduler and models
+    noise_scheduler = DDPMScheduler(
+        beta_start=0.00085,
+        beta_end=0.012,
+        beta_schedule="scaled_linear",
+        num_train_timesteps=1000,
+    )  # DDPMScheduler.from_pretrained(args.pretrained_model_name_or_path, subfolder="scheduler")
+    text_encoder = text_encoder_cls.from_pretrained(
+        args.pretrained_model_name_or_path, subfolder="text_encoder", revision=args.revision
+    )
+    vae = AutoencoderKL.from_pretrained(args.pretrained_model_name_or_path, subfolder="vae", revision=args.revision)
+    unet = UNet2DConditionModel.from_pretrained(
+        args.pretrained_model_name_or_path, subfolder="unet", revision=args.revision
+    )
+
+    if args.adapter != "full":
+        config = create_unet_adapter_config(args)
+        unet = get_peft_model(unet, config)
+        unet.print_trainable_parameters()
+        print(unet)
+
+    vae.requires_grad_(False)
+    if not args.train_text_encoder:
+        text_encoder.requires_grad_(False)
+    elif args.train_text_encoder and args.adapter != "full":
+        config = create_text_encoder_adapter_config(args)
+        text_encoder = get_peft_model(text_encoder, config)
+        text_encoder.print_trainable_parameters()
+        print(text_encoder)
+
+    if args.enable_xformers_memory_efficient_attention:
+        if accelerator.device.type == "xpu":
+            logger.warning("XPU hasn't support xformers yet, ignore it.")
+        elif is_xformers_available():
+            unet.enable_xformers_memory_efficient_attention()
+        else:
+            raise ValueError("xformers is not available. Make sure it is installed correctly")
+
+    if args.gradient_checkpointing:
+        unet.enable_gradient_checkpointing()
+        if args.train_text_encoder and args.adapter == "full":
+            text_encoder.gradient_checkpointing_enable()
+
+    # Enable TF32 for faster training on Ampere GPUs,
+    # cf https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices
+    if args.allow_tf32 and torch.cuda.is_available():
+        torch.backends.cuda.matmul.allow_tf32 = True
+
+    if args.scale_lr:
+        args.learning_rate = (
+            args.learning_rate * args.gradient_accumulation_steps * args.train_batch_size * accelerator.num_processes
+        )
+
+    # Use 8-bit Adam for lower memory usage or to fine-tune the model in 16GB accelerators
+    if args.use_8bit_adam:
+        try:
+            import bitsandbytes as bnb
+        except ImportError:
+            raise ImportError(
+                "To use 8-bit Adam, please install the bitsandbytes library: `pip install bitsandbytes`."
+            )
+
+        optimizer_class = bnb.optim.AdamW8bit
+    else:
+        optimizer_class = torch.optim.AdamW
+
+    # Optimizer creation
+    params_to_optimize = (
+        itertools.chain(unet.parameters(), text_encoder.parameters()) if args.train_text_encoder else unet.parameters()
+    )
+    optimizer = optimizer_class(
+        params_to_optimize,
+        lr=args.learning_rate,
+        betas=(args.adam_beta1, args.adam_beta2),
+        weight_decay=args.adam_weight_decay,
+        eps=args.adam_epsilon,
+    )
+
+    # Dataset and DataLoaders creation:
+    train_dataset = DreamBoothDataset(
+        instance_data_root=args.instance_data_dir,
+        instance_prompt=args.instance_prompt,
+        class_data_root=args.class_data_dir if args.with_prior_preservation else None,
+        class_prompt=args.class_prompt,
+        tokenizer=tokenizer,
+        size=args.resolution,
+        center_crop=args.center_crop,
+    )
+
+    train_dataloader = torch.utils.data.DataLoader(
+        train_dataset,
+        batch_size=args.train_batch_size,
+        shuffle=True,
+        collate_fn=lambda examples: collate_fn(examples, args.with_prior_preservation),
+        num_workers=1,
+    )
+
+    # Scheduler and math around the number of training steps.
+    overrode_max_train_steps = False
+    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
+    if args.max_train_steps is None:
+        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
+        overrode_max_train_steps = True
+
+    lr_scheduler = get_scheduler(
+        args.lr_scheduler,
+        optimizer=optimizer,
+        num_warmup_steps=args.lr_warmup_steps * args.gradient_accumulation_steps,
+        num_training_steps=args.max_train_steps * args.gradient_accumulation_steps,
+        num_cycles=args.lr_num_cycles,
+        power=args.lr_power,
+    )
+
+    # Prepare everything with our `accelerator`.
+    if args.train_text_encoder:
+        unet, text_encoder, optimizer, train_dataloader, lr_scheduler = accelerator.prepare(
+            unet, text_encoder, optimizer, train_dataloader, lr_scheduler
+        )
+    else:
+        unet, optimizer, train_dataloader, lr_scheduler = accelerator.prepare(
+            unet, optimizer, train_dataloader, lr_scheduler
+        )
+
+    # For mixed precision training we cast the text_encoder and vae weights to half-precision
+    # as these models are only used for inference, keeping weights in full precision is not required.
+    weight_dtype = torch.float32
+    if accelerator.mixed_precision == "fp16":
+        weight_dtype = torch.float16
+    elif accelerator.mixed_precision == "bf16":
+        weight_dtype = torch.bfloat16
+
+    # Move vae and text_encoder to device and cast to weight_dtype
+    vae.to(accelerator.device, dtype=weight_dtype)
+    if not args.train_text_encoder:
+        text_encoder.to(accelerator.device, dtype=weight_dtype)
+
+    # We need to recalculate our total training steps as the size of the training dataloader may have changed.
+    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
+    if overrode_max_train_steps:
+        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
+    # Afterwards we recalculate our number of training epochs
+    args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch)
+
+    # We need to initialize the trackers we use, and also store our configuration.
+    # The trackers initializes automatically on the main process.
+    if accelerator.is_main_process:
+        accelerator.init_trackers("dreambooth", config=vars(args))
+
+    # Train!
+    total_batch_size = args.train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps
+
+    logger.info("***** Running training *****")
+    logger.info(f"  Num examples = {len(train_dataset)}")
+    logger.info(f"  Num batches each epoch = {len(train_dataloader)}")
+    logger.info(f"  Num Epochs = {args.num_train_epochs}")
+    logger.info(f"  Instantaneous batch size per device = {args.train_batch_size}")
+    logger.info(f"  Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}")
+    logger.info(f"  Gradient Accumulation steps = {args.gradient_accumulation_steps}")
+    logger.info(f"  Total optimization steps = {args.max_train_steps}")
+    global_step = 0
+    first_epoch = 0
+
+    # Potentially load in the weights and states from a previous save
+    if args.resume_from_checkpoint:
+        if args.resume_from_checkpoint != "latest":
+            path = os.path.basename(args.resume_from_checkpoint)
+        else:
+            # Get the mos recent checkpoint
+            dirs = os.listdir(args.output_dir)
+            dirs = [d for d in dirs if d.startswith("checkpoint")]
+            dirs = sorted(dirs, key=lambda x: int(x.split("-")[1]))
+            path = dirs[-1]
+        accelerator.print(f"Resuming from checkpoint {path}")
+        accelerator.load_state(os.path.join(args.output_dir, path))
+        global_step = int(path.split("-")[1])
+
+        resume_global_step = global_step * args.gradient_accumulation_steps
+        first_epoch = resume_global_step // num_update_steps_per_epoch
+        resume_step = resume_global_step % num_update_steps_per_epoch
+
+    # Only show the progress bar once on each machine.
+    progress_bar = tqdm(range(global_step, args.max_train_steps), disable=not accelerator.is_local_main_process)
+    progress_bar.set_description("Steps")
+
+    for epoch in range(first_epoch, args.num_train_epochs):
+        unet.train()
+        if args.train_text_encoder:
+            text_encoder.train()
+        with TorchTracemalloc() as tracemalloc:
+            for step, batch in enumerate(train_dataloader):
+                # Skip steps until we reach the resumed step
+                if args.resume_from_checkpoint and epoch == first_epoch and step < resume_step:
+                    if step % args.gradient_accumulation_steps == 0:
+                        progress_bar.update(1)
+                        if args.report_to == "wandb":
+                            accelerator.print(progress_bar)
+                    continue
+
+                with accelerator.accumulate(unet):
+                    # Convert images to latent space
+                    latents = vae.encode(batch["pixel_values"].to(dtype=weight_dtype)).latent_dist.sample()
+                    latents = latents * 0.18215
+
+                    # Sample noise that we'll add to the latents
+                    noise = torch.randn_like(latents)
+                    bsz = latents.shape[0]
+                    # Sample a random timestep for each image
+                    timesteps = torch.randint(
+                        0, noise_scheduler.config.num_train_timesteps, (bsz,), device=latents.device
+                    )
+                    timesteps = timesteps.long()
+
+                    # Add noise to the latents according to the noise magnitude at each timestep
+                    # (this is the forward diffusion process)
+                    noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps)
+
+                    # Get the text embedding for conditioning
+                    encoder_hidden_states = text_encoder(batch["input_ids"])[0]
+
+                    # Predict the noise residual
+                    model_pred = unet(noisy_latents, timesteps, encoder_hidden_states).sample
+
+                    # Get the target for loss depending on the prediction type
+                    if noise_scheduler.config.prediction_type == "epsilon":
+                        target = noise
+                    elif noise_scheduler.config.prediction_type == "v_prediction":
+                        target = noise_scheduler.get_velocity(latents, noise, timesteps)
+                    else:
+                        raise ValueError(f"Unknown prediction type {noise_scheduler.config.prediction_type}")
+
+                    if args.with_prior_preservation:
+                        # Chunk the noise and model_pred into two parts and compute the loss on each part separately.
+                        model_pred, model_pred_prior = torch.chunk(model_pred, 2, dim=0)
+                        target, target_prior = torch.chunk(target, 2, dim=0)
+
+                        # Compute instance loss
+                        loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean")
+
+                        # Compute prior loss
+                        prior_loss = F.mse_loss(model_pred_prior.float(), target_prior.float(), reduction="mean")
+
+                        # Add the prior loss to the instance loss.
+                        loss = loss + args.prior_loss_weight * prior_loss
+                    else:
+                        loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean")
+
+                    accelerator.backward(loss)
+                    if accelerator.sync_gradients:
+                        params_to_clip = (
+                            itertools.chain(unet.parameters(), text_encoder.parameters())
+                            if args.train_text_encoder
+                            else unet.parameters()
+                        )
+                        accelerator.clip_grad_norm_(params_to_clip, args.max_grad_norm)
+                    optimizer.step()
+                    lr_scheduler.step()
+                    optimizer.zero_grad()
+
+                # Checks if the accelerator has performed an optimization step behind the scenes
+                if accelerator.sync_gradients:
+                    progress_bar.update(1)
+                    if args.report_to == "wandb":
+                        accelerator.print(progress_bar)
+                    global_step += 1
+
+                    # if global_step % args.checkpointing_steps == 0:
+                    #     if accelerator.is_main_process:
+                    #         save_path = os.path.join(args.output_dir, f"checkpoint-{global_step}")
+                    #         accelerator.save_state(save_path)
+                    #         logger.info(f"Saved state to {save_path}")
+
+                logs = {"loss": loss.detach().item(), "lr": lr_scheduler.get_last_lr()[0]}
+                progress_bar.set_postfix(**logs)
+                accelerator.log(logs, step=global_step)
+
+                if (
+                    args.validation_prompt is not None
+                    and (step + num_update_steps_per_epoch * epoch) % args.validation_steps == 0
+                ):
+                    logger.info(
+                        f"Running validation... \n Generating {args.num_validation_images} images with prompt:"
+                        f" {args.validation_prompt}."
+                    )
+                    # create pipeline
+                    pipeline = DiffusionPipeline.from_pretrained(
+                        args.pretrained_model_name_or_path,
+                        safety_checker=None,
+                        revision=args.revision,
+                    )
+                    # set `keep_fp32_wrapper` to True because we do not want to remove
+                    # mixed precision hooks while we are still training
+                    pipeline.unet = accelerator.unwrap_model(unet, keep_fp32_wrapper=True)
+                    pipeline.text_encoder = accelerator.unwrap_model(text_encoder, keep_fp32_wrapper=True)
+                    pipeline.scheduler = DPMSolverMultistepScheduler.from_config(pipeline.scheduler.config)
+                    pipeline = pipeline.to(accelerator.device)
+                    pipeline.set_progress_bar_config(disable=True)
+
+                    # Set evaliation mode
+                    pipeline.unet.eval()
+                    pipeline.text_encoder.eval()
+
+                    # run inference
+                    if args.seed is not None:
+                        generator = torch.Generator(device=accelerator.device).manual_seed(args.seed)
+                    else:
+                        generator = None
+                    images = []
+                    for _ in range(args.num_validation_images):
+                        image = pipeline(args.validation_prompt, num_inference_steps=25, generator=generator).images[0]
+                        images.append(image)
+
+                    for tracker in accelerator.trackers:
+                        if tracker.name == "tensorboard":
+                            np_images = np.stack([np.asarray(img) for img in images])
+                            tracker.writer.add_images("validation", np_images, epoch, dataformats="NHWC")
+                        if tracker.name == "wandb":
+                            import wandb
+
+                            tracker.log(
+                                {
+                                    "validation": [
+                                        wandb.Image(image, caption=f"{i}: {args.validation_prompt}")
+                                        for i, image in enumerate(images)
+                                    ]
+                                }
+                            )
+
+                    # Set evaliation mode
+                    pipeline.unet.train()
+                    pipeline.text_encoder.train()
+
+                    del pipeline
+                    if torch.cuda.is_available():
+                        torch.cuda.empty_cache()
+                    elif torch.xpu.is_available():
+                        torch.xpu.empty_cache()
+
+                if global_step >= args.max_train_steps:
+                    break
+        # Printing the accelerator memory usage details such as allocated memory, peak memory, and total memory usage
+        accelerator.print(
+            f"{accelerator.device.type.upper()} Memory before entering the train : {b2mb(tracemalloc.begin)}"
+        )
+        accelerator.print(
+            f"{accelerator.device.type.upper()} Memory consumed at the end of the train (end-begin): {tracemalloc.used}"
+        )
+        accelerator.print(
+            f"{accelerator.device.type.upper()} Peak Memory consumed during the train (max-begin): {tracemalloc.peaked}"
+        )
+        accelerator.print(
+            f"{accelerator.device.type.upper()} Total Peak Memory consumed during the train (max): {tracemalloc.peaked + b2mb(tracemalloc.begin)}"
+        )
+
+        accelerator.print(f"CPU Memory before entering the train : {b2mb(tracemalloc.cpu_begin)}")
+        accelerator.print(f"CPU Memory consumed at the end of the train (end-begin): {tracemalloc.cpu_used}")
+        accelerator.print(f"CPU Peak Memory consumed during the train (max-begin): {tracemalloc.cpu_peaked}")
+        accelerator.print(
+            f"CPU Total Peak Memory consumed during the train (max): {tracemalloc.cpu_peaked + b2mb(tracemalloc.cpu_begin)}"
+        )
+
+    # Create the pipeline using using the trained modules and save it.
+    accelerator.wait_for_everyone()
+    if accelerator.is_main_process:
+        if args.adapter != "full":
+            unwarpped_unet = accelerator.unwrap_model(unet)
+            unwarpped_unet.save_pretrained(
+                os.path.join(args.output_dir, "unet"), state_dict=accelerator.get_state_dict(unet)
+            )
+            if args.train_text_encoder:
+                unwarpped_text_encoder = accelerator.unwrap_model(text_encoder)
+                unwarpped_text_encoder.save_pretrained(
+                    os.path.join(args.output_dir, "text_encoder"),
+                    state_dict=accelerator.get_state_dict(text_encoder),
+                )
+        else:
+            pipeline = DiffusionPipeline.from_pretrained(
+                args.pretrained_model_name_or_path,
+                unet=accelerator.unwrap_model(unet),
+                text_encoder=accelerator.unwrap_model(text_encoder),
+                revision=args.revision,
+            )
+            pipeline.save_pretrained(args.output_dir)
+
+        if args.push_to_hub:
+            api.upload_folder(
+                repo_id=repo_id,
+                folder_path=args.output_dir,
+                commit_message="End of training",
+                run_as_future=True,
+            )
+
+    accelerator.end_training()
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    main(args)

tasks/tasksmith-c488fc138ba1/environment/source/examples/token_classification/peft_lora_ner.ipynb

@@ -0,0 +1,554 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Named Entity Recognition with Peft Model 🤗\n",
+    "\n",
+    "##### In this notebook, we will learn how to perform Named Entity Recognition(NER) on the CoNLL-2003 dataset using the Trainer class\n",
+    "\n",
+    "##### This notebook has been adapted from the main NLP course here - https://huggingface.co/learn/nlp-course/chapter7/2?fw=pt#fine-tuning-the-model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#install the required libraries\n",
+    "!pip install -q datasets evaluate transformers seqeval"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Import required libraries\n",
+    "from datasets import load_dataset\n",
+    "from transformers import AutoTokenizer, AutoModelForTokenClassification, DataCollatorForTokenClassification, TrainingArguments, Trainer, pipeline\n",
+    "from peft import get_peft_model, LoraConfig, TaskType\n",
+    "import evaluate\n",
+    "import numpy as np\n",
+    "from huggingface_hub import notebook_login"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "DatasetDict({\n",
+      "    train: Dataset({\n",
+      "        features: ['id', 'tokens', 'pos_tags', 'chunk_tags', 'ner_tags'],\n",
+      "        num_rows: 14041\n",
+      "    })\n",
+      "    validation: Dataset({\n",
+      "        features: ['id', 'tokens', 'pos_tags', 'chunk_tags', 'ner_tags'],\n",
+      "        num_rows: 3250\n",
+      "    })\n",
+      "    test: Dataset({\n",
+      "        features: ['id', 'tokens', 'pos_tags', 'chunk_tags', 'ner_tags'],\n",
+      "        num_rows: 3453\n",
+      "    })\n",
+      "})\n"
+     ]
+    }
+   ],
+   "source": [
+    "raw_datasets = load_dataset(\"conll2003\")\n",
+    "print(raw_datasets)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['EU', 'rejects', 'German', 'call', 'to', 'boycott', 'British', 'lamb', '.']"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Look at the tokens of the first training example\n",
+    "raw_datasets[\"train\"][0][\"tokens\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[3, 0, 7, 0, 0, 0, 7, 0, 0]"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Look at the NER tags of the first training example\n",
+    "raw_datasets[\"train\"][0][\"ner_tags\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['O', 'B-PER', 'I-PER', 'B-ORG', 'I-ORG', 'B-LOC', 'I-LOC', 'B-MISC', 'I-MISC']"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Get the label names for the NER tags\n",
+    "ner_feature = raw_datasets[\"train\"].features[\"ner_tags\"]\n",
+    "label_names = ner_feature.feature.names\n",
+    "label_names"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "EU    rejects German call to boycott British lamb . \n",
+      "B-ORG O       B-MISC O    O  O       B-MISC  O    O \n"
+     ]
+    }
+   ],
+   "source": [
+    "words = raw_datasets[\"train\"][0][\"tokens\"]\n",
+    "labels = raw_datasets[\"train\"][0][\"ner_tags\"]\n",
+    "line1 = \"\"\n",
+    "line2 = \"\"\n",
+    "for word, label in zip(words, labels):\n",
+    "    full_label = label_names[label]\n",
+    "    max_length = max(len(word), len(full_label))\n",
+    "    line1 += word + \" \" * (max_length - len(word) + 1)\n",
+    "    line2 += full_label + \" \" * (max_length - len(full_label) + 1)\n",
+    "\n",
+    "print(line1)\n",
+    "print(line2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load the tokenizer\n",
+    "model_checkpoint = \"bert-base-cased\"\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_checkpoint)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['[CLS]',\n",
+       " 'EU',\n",
+       " 'rejects',\n",
+       " 'German',\n",
+       " 'call',\n",
+       " 'to',\n",
+       " 'boycott',\n",
+       " 'British',\n",
+       " 'la',\n",
+       " '##mb',\n",
+       " '.',\n",
+       " '[SEP]']"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Tokenize the first training example\n",
+    "inputs = tokenizer(raw_datasets[\"train\"][0][\"tokens\"], is_split_into_words=True)\n",
+    "inputs.tokens()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def align_labels_with_tokens(labels, word_ids):\n",
+    "    new_labels = []\n",
+    "    current_word = None\n",
+    "    for word_id in word_ids:\n",
+    "        if word_id != current_word:\n",
+    "            # Start of a new word!\n",
+    "            current_word = word_id\n",
+    "            label = -100 if word_id is None else labels[word_id]\n",
+    "            new_labels.append(label)\n",
+    "        elif word_id is None:\n",
+    "            # Special token\n",
+    "            new_labels.append(-100)\n",
+    "        else:\n",
+    "            # Same word as previous token\n",
+    "            label = labels[word_id]\n",
+    "            # If the label is B-XXX we change it to I-XXX\n",
+    "            if label % 2 == 1:\n",
+    "                label += 1\n",
+    "            new_labels.append(label)\n",
+    "\n",
+    "    return new_labels"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[3, 0, 7, 0, 0, 0, 7, 0, 0]\n",
+      "[-100, 3, 0, 7, 0, 0, 0, 7, 0, 0, 0, -100]\n"
+     ]
+    }
+   ],
+   "source": [
+    "labels = raw_datasets[\"train\"][0][\"ner_tags\"]\n",
+    "word_ids = inputs.word_ids()\n",
+    "print(labels)\n",
+    "print(align_labels_with_tokens(labels, word_ids))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def tokenize_and_align_labels(examples):\n",
+    "    tokenized_inputs = tokenizer(\n",
+    "        examples[\"tokens\"], truncation=True, is_split_into_words=True\n",
+    "    )\n",
+    "    all_labels = examples[\"ner_tags\"]\n",
+    "    new_labels = []\n",
+    "    for i, labels in enumerate(all_labels):\n",
+    "        word_ids = tokenized_inputs.word_ids(i)\n",
+    "        new_labels.append(align_labels_with_tokens(labels, word_ids))\n",
+    "\n",
+    "    tokenized_inputs[\"labels\"] = new_labels\n",
+    "    return tokenized_inputs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tokenized_datasets = raw_datasets.map(\n",
+    "    tokenize_and_align_labels,\n",
+    "    batched=True,\n",
+    "    remove_columns=raw_datasets[\"train\"].column_names,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data_collator = DataCollatorForTokenClassification(tokenizer=tokenizer)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[-100, 3, 0, 7, 0, 0, 0, 7, 0, 0, 0, -100]\n",
+      "[-100, 1, 2, -100]\n"
+     ]
+    }
+   ],
+   "source": [
+    "for i in range(2):\n",
+    "    print(tokenized_datasets[\"train\"][i][\"labels\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "metric = evaluate.load(\"seqeval\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create label mappings\n",
+    "id2label = {i: label for i, label in enumerate(label_names)}\n",
+    "label2id = {v: k for k, v in id2label.items()}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load the pre-trained model\n",
+    "model = AutoModelForTokenClassification.from_pretrained(\n",
+    "    model_checkpoint,\n",
+    "    id2label=id2label,\n",
+    "    label2id=label2id,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "9"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.config.num_labels"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Configure LoRA (Low-Rank Adaptation) for fine-tuning\n",
+    "peft_config = LoraConfig(target_modules = [\"query\", \"key\"], task_type = TaskType.TOKEN_CLS)\n",
+    "\n",
+    "model = get_peft_model(model, peft_config)\n",
+    "model.print_trainable_parameters()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def compute_metrics(eval_preds):\n",
+    "    logits, labels = eval_preds\n",
+    "    predictions = np.argmax(logits, axis=-1)\n",
+    "\n",
+    "    # Remove ignored index (special tokens) and convert to labels\n",
+    "    true_labels = [[label_names[l] for l in label if l != -100] for label in labels]\n",
+    "    true_predictions = [\n",
+    "        [label_names[p] for (p, l) in zip(prediction, label) if l != -100]\n",
+    "        for prediction, label in zip(predictions, labels)\n",
+    "    ]\n",
+    "    all_metrics = metric.compute(predictions=true_predictions, references=true_labels)\n",
+    "    return {\n",
+    "        \"precision\": all_metrics[\"overall_precision\"],\n",
+    "        \"recall\": all_metrics[\"overall_recall\"],\n",
+    "        \"f1\": all_metrics[\"overall_f1\"],\n",
+    "        \"accuracy\": all_metrics[\"overall_accuracy\"],\n",
+    "    }"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "notebook_login()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "args = TrainingArguments(\n",
+    "    \"bert-finetuned-ner-lora\",\n",
+    "    eval_strategy=\"epoch\",\n",
+    "    per_device_train_batch_size=32, # decrease this for OOM error\n",
+    "    per_device_eval_batch_size=64,\n",
+    "    save_strategy=\"epoch\",\n",
+    "    learning_rate=2e-3,\n",
+    "    num_train_epochs=5,\n",
+    "    weight_decay=0.01,\n",
+    "    load_best_model_at_end=True,\n",
+    "    do_eval=True,\n",
+    "    do_predict=True,\n",
+    "    metric_for_best_model=\"accuracy\",\n",
+    "    label_names=[\"labels\"],\n",
+    "    push_to_hub=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "trainer = Trainer(\n",
+    "    model=model,\n",
+    "    args=args,\n",
+    "    train_dataset=tokenized_datasets[\"train\"],\n",
+    "    eval_dataset=tokenized_datasets[\"validation\"],\n",
+    "    data_collator=data_collator,\n",
+    "    processing_class=tokenizer,\n",
+    "    compute_metrics=compute_metrics\n",
+    ")\n",
+    "trainer.train()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Some weights of BertForTokenClassification were not initialized from the model checkpoint at bert-base-cased and are newly initialized: ['classifier.bias', 'classifier.weight']\n",
+      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n",
+      "Device set to use xpu:0\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "entity_idx: 0, id2label: {0: 'O', 1: 'B-PER', 2: 'I-PER', 3: 'B-ORG', 4: 'I-ORG', 5: 'B-LOC', 6: 'I-LOC', 7: 'B-MISC', 8: 'I-MISC'}\n",
+      "entity_idx: 0, id2label: {0: 'O', 1: 'B-PER', 2: 'I-PER', 3: 'B-ORG', 4: 'I-ORG', 5: 'B-LOC', 6: 'I-LOC', 7: 'B-MISC', 8: 'I-MISC'}\n",
+      "entity_idx: 0, id2label: {0: 'O', 1: 'B-PER', 2: 'I-PER', 3: 'B-ORG', 4: 'I-ORG', 5: 'B-LOC', 6: 'I-LOC', 7: 'B-MISC', 8: 'I-MISC'}\n",
+      "entity_idx: 1, id2label: {0: 'O', 1: 'B-PER', 2: 'I-PER', 3: 'B-ORG', 4: 'I-ORG', 5: 'B-LOC', 6: 'I-LOC', 7: 'B-MISC', 8: 'I-MISC'}\n",
+      "entity_idx: 2, id2label: {0: 'O', 1: 'B-PER', 2: 'I-PER', 3: 'B-ORG', 4: 'I-ORG', 5: 'B-LOC', 6: 'I-LOC', 7: 'B-MISC', 8: 'I-MISC'}\n",
+      "entity_idx: 0, id2label: {0: 'O', 1: 'B-PER', 2: 'I-PER', 3: 'B-ORG', 4: 'I-ORG', 5: 'B-LOC', 6: 'I-LOC', 7: 'B-MISC', 8: 'I-MISC'}\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "[{'entity_group': 'PER',\n",
+       "  'score': 0.9702984,\n",
+       "  'word': 'Jino',\n",
+       "  'start': 11,\n",
+       "  'end': 15}]"
+      ]
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from peft import PeftModel\n",
+    "\n",
+    "# Replace this with your own checkpoint\n",
+    "lora_checkpoint = \"./bert-finetuned-ner-lora\"\n",
+    "\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_checkpoint)\n",
+    "base_model = AutoModelForTokenClassification.from_pretrained(\n",
+    "    model_checkpoint,\n",
+    "    id2label=id2label,\n",
+    "    label2id=label2id,\n",
+    ")\n",
+    "lora_model = PeftModel.from_pretrained(base_model, lora_checkpoint)\n",
+    "token_classifier = pipeline(\n",
+    "    \"token-classification\", model=lora_model, tokenizer=tokenizer, aggregation_strategy=\"simple\"\n",
+    ")\n",
+    "\n",
+    "token_classifier(\"My name is Jino.\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

tasks/tasksmith-c488fc138ba1/environment/source/examples/token_classification/requirements.txt

@@ -0,0 +1,7 @@
+transformers
+accelerate
+evaluate
+tqdm
+datasets
+Pillow
+torchvision

tasks/tasksmith-c488fc138ba1/environment/source/examples/waveft_finetuning/README.md

@@ -0,0 +1,64 @@
+
+
+# WaveFT: Wavelet Fine-Tuning
+
+## Introduction
+[WaveFT](https://huggingface.co/papers/2505.12532) is a novel parameter-efficient fine-tuning (PEFT) method that introduces sparse updates in the **wavelet domain** of residual matrices. Unlike LoRA, which is constrained by discrete low-rank choices, WaveFT enables fine-grained control over the number of trainable parameters by directly learning a sparse set of coefficients in the transformed space. These coefficients are then mapped back to the weight domain via the Inverse Discrete Wavelet Transform (IDWT), producing high-rank updates without incurring inference overhead.
+
+## Quick start
+```python
+import torch
+from peft import WaveFTConfig, get_peft_model
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from trl import SFTConfig, SFTTrainer
+from datasets import load_dataset
+
+model = AutoModelForCausalLM.from_pretrained("facebook/opt-350m", dtype=torch.bfloat16, device_map="auto")
+tokenizer = AutoTokenizer.from_pretrained("facebook/opt-350m")
+dataset = load_dataset("imdb", split="train[:1%]")
+waveft_config = WaveFTConfig(
+    n_frequency=2592,
+)
+peft_model = get_peft_model(model, waveft_config)
+training_args = SFTConfig(dataset_text_field="text", max_length=128)
+trainer = SFTTrainer(
+    model=peft_model,
+    train_dataset=dataset,
+    processing_class=tokenizer,
+)
+trainer.train()
+peft_model.save_pretrained("waveft-opt-350m")
+```
+
+For more options and a more detailed example code, you can refer to waveft finetuning script.
+Run the script simply by running:
+```bash
+python3 examples/waveft_finetuning/waveft_finetuning.py --base_model facebook/opt-350m
+```
+
+If you want to run DDP by [accelerate](https://huggingface.co/docs/accelerate/en/index), please run `accelerate config` to set your ddp config, and run:
+```bash
+accelerate launch examples/waveft_finetuning/waveft_finetuning.py --base_model facebook/opt-350m
+```
+please add `--device_map cpu` if you want to run finetune on CPU.
+
+## Use the model
+You can load and use the model as any other 🤗 PEFT model
+```python
+from peft import PeftModel
+from transformers import AutoTokenizer, AutoModelForCausalLM
+model = AutoModelForCausalLM.from_pretrained("facebook/opt-350m")
+tokenizer = AutoTokenizer.from_pretrained("facebook/opt-350m")
+waveft_model = PeftModel.from_pretrained(model, "waveft-opt-350m")
+```
+
+## Citation
+@misc{bilican2025exploringsparsityparameterefficient,
+      title={Exploring Sparsity for Parameter Efficient Fine Tuning Using Wavelets}, 
+      author={Ahmet Bilican and M. Akın Yılmaz and A. Murat Tekalp and R. Gökberk Cinbiş},
+      year={2025},
+      eprint={2505.12532},
+      archivePrefix={arXiv},
+      primaryClass={cs.CV},
+      url={https://arxiv.org/abs/2505.12532}, 
+}

tasks/tasksmith-c488fc138ba1/environment/source/examples/waveft_finetuning/waveft_finetuning.py

@@ -0,0 +1,189 @@
+# Copyright 2025-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import os
+from typing import Optional
+
+import torch
+import transformers
+from datasets import load_dataset
+from transformers import AutoModelForCausalLM, AutoTokenizer, set_seed
+
+from peft import (
+    WaveFTConfig,
+    get_peft_model,
+)
+
+
+def train(
+    base_model: str,
+    data_path: str = "yahma/alpaca-cleaned",
+    output_dir: str = "waveft",
+    batch_size: int = 16,
+    num_epochs: int = 1,
+    learning_rate: float = 3e-4,
+    cutoff_len: int = 256,
+    val_set_size: int = 16,
+    eval_step: int = 100,
+    save_step: int = 100,
+    device_map: str = "auto",
+    waveft_n_frequency: int = 2592,
+    waveft_target_modules: Optional[list[str]] = None,
+    waveft_scaling: float = 25.0,
+    waveft_wavelet_family: str = "db1",
+    waveft_use_idwt: bool = True,
+    dtype: str = "float16",
+    seed: Optional[int] = None,
+):
+    # Set device_map to the right place when enabling DDP.
+    world_size = int(os.environ.get("WORLD_SIZE", "0")) or int(os.environ.get("PMI_SIZE", "0"))
+    if world_size > 1 and device_map != "cpu":
+        from accelerate import Accelerator
+
+        device_map = {"": Accelerator().process_index}
+    # Set seed
+    if seed is not None:
+        set_seed(seed)
+    model_kwargs = {"dtype": getattr(torch, dtype), "device_map": device_map}
+    model = AutoModelForCausalLM.from_pretrained(base_model, **model_kwargs)
+
+    tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)
+    # For some tokenizer with no pad token like llama
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+
+    def tokenize(prompt, add_eos_token=True):
+        result = tokenizer(
+            prompt,
+            truncation=True,
+            max_length=cutoff_len,
+            padding=False,
+            return_tensors=None,
+        )
+        if (
+            result["input_ids"][-1] != tokenizer.eos_token_id
+            and len(result["input_ids"]) < cutoff_len
+            and add_eos_token
+        ):
+            result["input_ids"].append(tokenizer.eos_token_id)
+            result["attention_mask"].append(1)
+
+        result["labels"] = result["input_ids"].copy()
+
+        return result
+
+    def generate_and_tokenize_prompt(example):
+        full_prompt = generate_prompt(example)
+        tokenized_full_prompt = tokenize(full_prompt)
+        return tokenized_full_prompt
+
+    config = WaveFTConfig(
+        n_frequency=waveft_n_frequency,
+        scaling=waveft_scaling,
+        wavelet_family=waveft_wavelet_family,
+        use_idwt=waveft_use_idwt,
+        target_modules=waveft_target_modules,
+        task_type="CAUSAL_LM",
+    )
+
+    model = get_peft_model(model, config)
+
+    data = load_dataset(data_path)
+
+    train_val = data["train"].train_test_split(test_size=val_set_size, shuffle=True, seed=42)
+    train_data = train_val["train"].shuffle().map(generate_and_tokenize_prompt)
+    val_data = train_val["test"].shuffle().map(generate_and_tokenize_prompt)
+
+    trainer = transformers.Trainer(
+        model=model,
+        train_dataset=train_data,
+        eval_dataset=val_data,
+        args=transformers.TrainingArguments(
+            per_device_train_batch_size=batch_size,
+            warmup_steps=100,
+            num_train_epochs=num_epochs,
+            learning_rate=learning_rate,
+            logging_steps=100,
+            optim="adamw_torch",
+            eval_strategy="steps",
+            save_strategy="steps",
+            eval_steps=eval_step,
+            save_steps=save_step,
+            output_dir=output_dir,
+            save_total_limit=3,
+            load_best_model_at_end=True,
+            ddp_find_unused_parameters=False if world_size > 1 else None,
+        ),
+        data_collator=transformers.DataCollatorForSeq2Seq(
+            tokenizer, pad_to_multiple_of=8, return_tensors="pt", padding=True
+        ),
+    )
+    trainer.train()
+    model.save_pretrained(output_dir)
+
+
+def generate_prompt(example):
+    return f"""Below is an instruction that describes a task. Write a response that appropriately completes the request.
+            ### Instruction:
+            {example["instruction"]}
+            ### Response:
+            {example["output"]}"""
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--base_model", type=str)
+    parser.add_argument("--data_path", type=str, default="yahma/alpaca-cleaned")
+    parser.add_argument("--output_dir", type=str, default="waveft")
+    parser.add_argument("--batch_size", type=int, default=16)
+    parser.add_argument("--num_epochs", type=int, default=1)
+    parser.add_argument("--learning_rate", type=float, default=3e-4)
+    parser.add_argument("--cutoff_len", type=int, default=256)
+    parser.add_argument("--val_set_size", type=int, default=16)
+    parser.add_argument("--eval_step", type=int, default=100)
+    parser.add_argument("--save_step", type=int, default=100)
+    parser.add_argument("--device_map", type=str, default="auto")
+    parser.add_argument("--waveft_n_frequency", type=int, default=2592)
+    parser.add_argument("--waveft_target_modules", type=str, default=None)
+    parser.add_argument("--waveft_scaling", type=float, default=25.0)
+    parser.add_argument("--waveft_wavelet_family", type=str, default="db1")
+    parser.add_argument("--waveft_use_idwt", action="store_true", default=True)
+    parser.add_argument("--dtype", type=str, default="float16")
+    parser.add_argument("--seed", type=int, default=None)
+
+    args = parser.parse_args()
+
+    train(
+        base_model=args.base_model,
+        data_path=args.data_path,
+        output_dir=args.output_dir,
+        batch_size=args.batch_size,
+        num_epochs=args.num_epochs,
+        learning_rate=args.learning_rate,
+        cutoff_len=args.cutoff_len,
+        val_set_size=args.val_set_size,
+        eval_step=args.eval_step,
+        save_step=args.save_step,
+        device_map=args.device_map,
+        waveft_n_frequency=args.waveft_n_frequency,
+        waveft_target_modules=args.waveft_target_modules,
+        waveft_scaling=args.waveft_scaling,
+        waveft_wavelet_family=args.waveft_wavelet_family,
+        waveft_use_idwt=args.waveft_use_idwt,
+        dtype=args.dtype,
+        seed=args.seed,
+    )

tasks/tasksmith-c488fc138ba1/environment/source/examples/xlora/README.md

@@ -0,0 +1,15 @@
+# X-LoRA examples
+
+## `xlora_inference_mistralrs.py`
+
+Perform inference of an X-LoRA model using the inference engine mistral.rs.
+
+Mistral.rs supports many base models besides Mistral, and can load models directly from saved LoRA checkpoints. Check out [adapter model docs](https://github.com/EricLBuehler/mistral.rs/blob/master/docs/ADAPTER_MODELS.md) and the [models support matrix](https://github.com/EricLBuehler/mistral.rs?tab=readme-ov-file#support-matrix).
+
+Mistral.rs features X-LoRA support and incorporates techniques such as a dual-KV cache, continuous batching, Paged Attention, and optional non granular scalings, will allow vastly improved throughput.    
+
+Links:
+
+- Installation: https://github.com/EricLBuehler/mistral.rs/blob/master/mistralrs-pyo3/README.md
+- Runnable example: https://github.com/EricLBuehler/mistral.rs/blob/master/examples/python/xlora_zephyr.py
+- Adapter model docs and making the ordering file: https://github.com/EricLBuehler/mistral.rs/blob/master/docs/ADAPTER_MODELS.md

tasks/tasksmith-c488fc138ba1/environment/source/examples/xlora/xlora_inference_mistralrs.py

@@ -0,0 +1,25 @@
+from mistralrs import ChatCompletionRequest, Runner, Which
+
+
+runner = Runner(
+    which=Which.XLora(
+        tok_model_id=None,  # Automatically determine from ordering file
+        model_id=...,  # Model ID of the base model (local path of HF model ID)
+        xlora_model_id=...,  # X-LoRA Model ID of the base model (local path of HF model ID)
+        order=...,  # Ordering file to ensure compatability with PEFT
+        tgt_non_granular_index=3,  # Only generate scalings for the first 3 decoding tokens, and then use the last generated one
+    )
+)
+
+res = runner.send_chat_completion_request(
+    ChatCompletionRequest(
+        model="mistral",
+        messages=[{"role": "user", "content": "Tell me a story about 2 low rank matrices."}],
+        max_tokens=256,
+        presence_penalty=1.0,
+        top_p=0.1,
+        temperature=0.5,
+    )
+)
+print(res.choices[0].message.content)
+print(res.usage)

tasks/tasksmith-c488fc138ba1/environment/source/pyproject.toml

@@ -0,0 +1,67 @@
+[tool.black]
+# Only used by `hf-doc-builder´.
+line-length = 119
+target-version = ['py310']
+
+[tool.ruff]
+target-version = "py310"
+line-length = 119
+extend-exclude = ["*.ipynb"]
+required-version = "~=0.15.12"
+
+[tool.ruff.lint]
+preview = true
+explicit-preview-rules = true
+extend-select = [
+    "C", # Complexity
+    "E", # PEP8 errors
+    "F", # PEP8 formatting
+    "I", # Import sorting
+    "UP", # Pyupgrade upgrades
+    "W", # PEP8 warnings
+    "PT009", # Pytest assertions
+    "RUF022", # Sorting of __all__
+]
+ignore = [
+    "C901", # Function too complex
+    "E501", # Line length (handled by ruff-format)
+    "F841", # unused variable
+    "UP007", # X | Y style Unions
+    "C420", # dict.fromkeys
+    "UP045", # don't force replacing Optional[X] with X | None
+    "SIM118", # `for key in dct.keys()` is allowed
+    "PLC0206", # allow iterating over dict keys and pulling values later, can be more consistent
+    "RUF012", # allow mutable default values, contrary to popular belief, not always evil
+    "B018", # a "useless expression" is not useless when it tests for an AttributeError
+    "SIM117", # allow nesting of `with` statements: can be *more* readable of they are long
+    "BLE001", # allow catching bare `Exception`
+    "SIM102", # collapse multiple `if` statements: nice to have but requires too many changes
+    "PYI041", # considers type annotations like int|float as redundant and wants float only, but type can carry semantic meaning (e.g. total number vs fraction)
+]
+
+[tool.ruff.lint.isort]
+lines-after-imports = 2
+known-first-party = ["peft"]
+
+[tool.pytest]
+doctest_optionflags = [
+    "NORMALIZE_WHITESPACE",
+    "ELLIPSIS",
+    "NUMBER",
+]
+
+addopts = ["--cov=src/peft", "--cov-report=term-missing", "--durations=10"]
+
+markers = [
+    "single_gpu_tests: tests that run on a single GPU",
+    "multi_gpu_tests: tests that run on multiple GPUs",
+    "regression: whether to run regression suite test",
+    "bitsandbytes: select bitsandbytes integration tests",
+]
+
+filterwarnings = [
+    "error::DeprecationWarning:transformers",
+    # in sync with tests/conftest.py regarding BPE deprecation
+    "ignore:.*BPE.__init__ will not create from files anymore.*:DeprecationWarning:transformers",
+    "error::FutureWarning:transformers",
+]

tasks/tasksmith-c488fc138ba1/environment/source/requirements.txt

@@ -0,0 +1,15 @@
+accelerate
+torch
+safetensors
+bitsandbytes
+scipy
+peft
+transformers
+tqdm
+packaging
+pytest
+numpy
+pyyaml
+datasets
+psutil
+setuptools

tasks/tasksmith-c488fc138ba1/environment/source/scripts/ci_clean_cache.py

@@ -0,0 +1,68 @@
+"""
+Utility to clean cache files that exceed a specific time in days according to their
+last access time recorded in the cache.
+
+Exit code:
+- 1 if no candidates are found
+- 0 if candidates are found
+
+Deletion can be enabled by passing `-d` parameter, otherwise it will only list the candidates.
+"""
+
+import sys
+from datetime import datetime as dt
+from datetime import timezone
+
+from huggingface_hub import scan_cache_dir
+
+
+def find_old_revisions(scan_results, max_age_days=30):
+    """Find commit hashes of objects in the cache. These objects need a last access time that
+    is above the passed `max_age_days` parameter. Returns an empty list if no objects are found.
+    Time measurement is based of the current time and the recorded last access tiem in the cache.
+    """
+    now = dt.now(timezone.utc)
+    revisions = [(i.revisions, i.last_accessed) for i in scan_results.repos]
+    revisions_ages = [(rev, (now - dt.fromtimestamp(ts_access, timezone.utc)).days) for rev, ts_access in revisions]
+    delete_candidates = [rev for rev, age in revisions_ages if age > max_age_days]
+    hashes = [n.commit_hash for rev in delete_candidates for n in rev]
+
+    return hashes
+
+
+def delete_old_revisions(scan_results, delete_candidates, do_delete=False):
+    delete_operation = scan_results.delete_revisions(*delete_candidates)
+    print(f"Would free {delete_operation.expected_freed_size_str}")
+    print(f"Candidates: {delete_candidates}")
+
+    if do_delete:
+        print("Deleting now.")
+        delete_operation.execute()
+    else:
+        print("Not deleting, pass the -d flag.")
+
+
+if __name__ == "__main__":
+    from argparse import ArgumentParser
+
+    parser = ArgumentParser()
+    parser.add_argument("-a", "--max-age", type=int, default=30, help="Max. age in days items in the cache may have.")
+    parser.add_argument(
+        "-d",
+        "--delete",
+        action="store_true",
+        help=(
+            "Delete mode; Really delete items if there are candidates. Exit code = 0 when we found something to delete, 1 "
+            "otherwise."
+        ),
+    )
+    args = parser.parse_args()
+
+    scan_results = scan_cache_dir()
+
+    delete_candidates = find_old_revisions(scan_results, args.max_age)
+    if not delete_candidates:
+        print("No delete candidates found, not deleting anything.")
+        sys.exit(1)
+
+    delete_old_revisions(scan_results, delete_candidates, do_delete=args.delete)

tasks/tasksmith-c488fc138ba1/environment/source/scripts/convert-bone-to-miss.py

@@ -0,0 +1,69 @@
+# Copyright (c) 2025 Your Organization/Project. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Convert Bone checkpoint to MiSS format."""
+
+import argparse
+import json
+import os
+from pathlib import Path
+
+from safetensors import safe_open
+from safetensors.torch import save_file
+
+from peft.utils import CONFIG_NAME, SAFETENSORS_WEIGHTS_NAME
+
+
+def convert_bone_to_miss(bone_dir: Path, miss_dir: Path) -> None:
+    """Convert Bone checkpoint files to MiSS format."""
+    bone_config_path = bone_dir / CONFIG_NAME
+    miss_config_path = miss_dir / CONFIG_NAME
+    if not os.path.exists(miss_dir):
+        os.makedirs(miss_dir, exist_ok=True)
+    with open(bone_config_path, encoding="utf-8") as f:
+        config = json.load(f)
+
+    config["peft_type"] = "MISS"
+
+    with open(miss_config_path, "w", encoding="utf-8") as f:
+        json.dump(config, f, indent=2, ensure_ascii=False)
+
+    bone_weight_path = bone_dir / SAFETENSORS_WEIGHTS_NAME
+    miss_weight_path = miss_dir / SAFETENSORS_WEIGHTS_NAME
+
+    new_data = {}
+
+    with safe_open(bone_weight_path, framework="pt") as f:
+        for old_key in f.keys():
+            tensor = f.get_tensor(old_key)
+            new_key = old_key.replace(".bone_", ".miss_")
+            new_data[new_key] = tensor
+
+    save_file(new_data, miss_weight_path)
+
+    print(f"Converted checkpoint saved at {miss_weight_path}")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Convert Bone checkpoint to MiSS format.")
+    parser.add_argument("bone_dir", type=Path, help="Directory containing Bone checkpoint files")
+    parser.add_argument("miss_dir", type=Path, help="Directory to save MiSS checkpoint files")
+    args = parser.parse_args()
+
+    args.miss_dir.mkdir(parents=True, exist_ok=True)
+    convert_bone_to_miss(args.bone_dir, args.miss_dir)
+
+
+if __name__ == "__main__":
+    main()

tasks/tasksmith-c488fc138ba1/environment/source/scripts/evaluate-lora-conversion.py

@@ -0,0 +1,156 @@
+# Copyright 2025-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Script to evaluate a PEFT checkpoint converted into a LoRA on GSM8K
+
+To run this script, first train a PEFT model on MetaMathQA as described here:
+
+https://github.com/huggingface/peft/tree/main/method_comparison/MetaMathQA
+
+Call the script with the `-v` (verbose) option. When that run finishes, it will save a checkpoint of that model and
+print a message like this: "Saved PEFT checkpoint to ...". Use this path as the `--path` argument to this script.
+
+Example usage:
+
+```bash
+# Convert to LoRA with rank 8 and evaluate it
+python evaluate-lora-conversion.py --path /path/to/peft/checkpoint --rank 8
+# Convert to LoRA with dynamic rank (50% singular value threshold) and evaluate it
+python evaluate-lora-conversion.py --path /path/to/peft/checkpoint --rank 0.5
+# Evaluate the original PEFT model without LoRA conversion
+python evaluate-lora-conversion.py --path /path/to/peft/checkpoint
+```
+
+The script will report the evaluation accuracy, maximum CUDA memory reserved, and evaluation time for the converted LoRA
+model.
+
+"""
+
+import argparse
+import importlib.util
+import os
+import sys
+import time
+
+import torch
+from transformers import AutoModelForCausalLM
+
+from peft import PeftModel, convert_to_lora, get_peft_model, set_peft_model_state_dict
+
+
+root = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+
+spec = importlib.util.spec_from_file_location("data", os.path.join(root, "method_comparison", "MetaMathQA", "data.py"))
+mm_data = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(mm_data)
+sys.modules["data"] = mm_data
+
+spec = importlib.util.spec_from_file_location(
+    "utils", os.path.join(root, "method_comparison", "MetaMathQA", "utils.py")
+)
+mm_utils = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(mm_utils)
+sys.modules["utils"] = mm_utils
+
+spec = importlib.util.spec_from_file_location("run", os.path.join(root, "method_comparison", "MetaMathQA", "run.py"))
+mm_run = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(mm_run)
+
+
+def noop(*args, **kwargs):
+    pass
+
+
+def evaluate_model(model, tokenizer, ds_test):
+    torch.cuda.empty_cache()
+    torch.cuda.reset_peak_memory_stats()
+    tic = time.perf_counter()
+    predictions, responses = mm_run.evaluate(
+        model=model,
+        tokenizer=tokenizer,
+        ds=ds_test,
+        batch_size=50,
+        generate_kwargs={"max_length": 800, "max_new_tokens": 300, "pad_token_id": tokenizer.eos_token_id},
+        use_tqdm=True,
+    )
+    toc = time.perf_counter()
+    accuracy_peft = mm_utils.get_accuracy(predictions=predictions, responses=responses)
+    cuda_mem_reserved_max = torch.cuda.memory_reserved(0)
+    print(f"Evaluation Accuracy: {100 * accuracy_peft:.2f}%")
+    print(f"Max CUDA Memory Reserved: {cuda_mem_reserved_max / (1024**3):.2f} GB")
+    print(f"Evaluation Time: {toc - tic:.0f} seconds".format(toc - tic))
+
+
+def main(path_peft_model: str, rank: float | None) -> None:
+    model_id = "meta-llama/Llama-3.2-3B"
+    tokenizer = mm_utils.get_tokenizer(model_id=model_id, max_seq_length=768)
+    _, _, ds_test = mm_data.get_train_valid_test_datasets(
+        tokenizer=tokenizer, query_template="Question: {query} Think step by step.\nAnswer:", print_fn=noop
+    )
+
+    model = AutoModelForCausalLM.from_pretrained(model_id, dtype=torch.bfloat16).to(0)
+    model = PeftModel.from_pretrained(model, path_peft_model)
+    if rank is None:
+        print("Evaluating the original PEFT model without LoRA conversion...")
+        model.set_adapter("default")
+        model.print_trainable_parameters()
+        model.eval()
+        evaluate_model(model, tokenizer, ds_test)
+        return
+
+    print(f"Converting PEFT model to LoRA with rank={rank}...")
+    tic = time.perf_counter()
+    lora_config, lora_state_dict = convert_to_lora(model, rank=rank, progressbar=True)
+    toc = time.perf_counter()
+    print(f"Conversion completed in {toc - tic:.0f} seconds.".format(toc - tic))
+
+    del model
+    torch.cuda.empty_cache()
+    model = AutoModelForCausalLM.from_pretrained(model_id, dtype=torch.bfloat16).to(0)
+
+    model = get_peft_model(model, lora_config)
+    model.print_trainable_parameters()
+
+    load_result = set_peft_model_state_dict(model, lora_state_dict)
+    assert not load_result.unexpected_keys, (
+        f"Unexpected keys when loading LoRA state dict: {load_result.unexpected_keys}"
+    )
+
+    del lora_state_dict
+    model.eval()
+    evaluate_model(model, tokenizer, ds_test)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Evaluate a PEFT checkpoint converted into a LoRA on GSM8K")
+    parser.add_argument(
+        "--path",
+        type=str,
+        required=True,
+        help="Path to the input PEFT checkpoint",
+    )
+    parser.add_argument(
+        "--rank",
+        required=False,
+        default=None,
+        help="Rank for the LoRA decomposition (int, float, or None for no conversion)",
+    )
+
+    args = parser.parse_args()
+    if args.rank is not None:
+        if "." in str(args.rank):
+            args.rank = float(args.rank)
+        else:
+            args.rank = int(args.rank)
+    main(args.path, args.rank)

tasks/tasksmith-c488fc138ba1/environment/source/scripts/generate_method_capabilities.py

@@ -0,0 +1,769 @@
+# Copyright 2026-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Generate a machine-readable capability matrix of all PEFT methods.
+
+For each registered PEFT method, a fixed set of checks ("tasks") determines which user-facing features the method
+supports, e.g. which quantization backends it integrates with, which layer types it can target, or whether its adapters
+can be merged into the base weights. The result is written as JSON and is intended as a generic data source, e.g. for
+documentation pages or the PEFT shop app (method_comparison/peft-shop).
+
+Each value is annotated with the *source* of the information:
+
+- "introspection": determined by statically inspecting the classes of the installed PEFT package
+- "file_check":    determined from the presence of integration modules in the PEFT source tree
+- "probe":         determined empirically by exercising the feature on a tiny model on CPU
+- "error":         the check itself failed; the value is "unknown" and the note contains the reason
+
+Values are never guessed: if a check cannot determine a feature, the value is reported as "unknown" together with a
+note. In particular, probing a method requires that its config can be instantiated with default arguments; methods that
+need more than that must have an entry in PROBE_CONFIG_OVERRIDES.
+
+The script requires PEFT to be installed (e.g. `pip install -e .`), runs on CPU, downloads nothing, and is idempotent:
+running it twice on the same environment produces identical output.
+
+Usage examples:
+
+    # check all methods, write JSON to method_capabilities.json
+    python scripts/generate_method_capabilities.py
+
+    # check only LoRA and IA3, write to a custom file
+    python scripts/generate_method_capabilities.py --methods lora ia3 --output capabilities.json
+
+    # show which checks would run, without running them
+    python scripts/generate_method_capabilities.py --dry-run
+
+Tasks are collected up-front before any of them runs (see `collect_tasks`). This makes `--dry-run` trivial and leaves
+the door open to run independent tasks in parallel later, should runtime ever become an issue.
+"""
+
+import argparse
+import dataclasses
+import enum
+import inspect
+import json
+import logging
+import re
+import sys
+import warnings
+from abc import ABC, abstractmethod
+from collections.abc import Callable
+from copy import deepcopy
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, ClassVar
+
+import torch
+from torch import nn
+from tqdm import tqdm
+from transformers import LlamaConfig, LlamaForCausalLM
+from transformers.pytorch_utils import Conv1D
+
+import peft
+from peft import get_peft_model
+from peft.config import PeftConfig, PromptLearningConfig
+from peft.mapping import PEFT_TYPE_TO_CONFIG_MAPPING, PEFT_TYPE_TO_MIXED_MODEL_MAPPING, PEFT_TYPE_TO_TUNER_MAPPING
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer
+from peft.utils.hotswap import CONFIG_KEYS_TO_CHECK
+from peft.utils.peft_types import PeftType
+
+
+logger = logging.getLogger("generate_method_capabilities")
+
+UNKNOWN = "unknown"
+NOT_APPLICABLE = "not_applicable"
+
+# Probe models use this hidden dimension throughout. It is chosen to be highly divisible, since several methods have
+# divisibility constraints between their block/rank settings and the layer dimensions (e.g. C3A, VBLoRA, RoAd).
+HIDDEN_DIM = 64
+
+# Quantization integration modules inside a tuner package, mapped to the backend names they provide. The bnb module
+# always contains both the 8-bit and the 4-bit integration.
+QUANT_FILE_BACKENDS: dict[str, tuple[str, ...]] = {
+    "aqlm": ("aqlm",),
+    "awq": ("awq",),
+    "bnb": ("bnb_8bit", "bnb_4bit"),
+    "eetq": ("eetq",),
+    "gptq": ("gptq",),
+    "hqq": ("hqq",),
+    "inc": ("inc",),
+    "torchao": ("torchao",),
+}
+
+# Backends covered by the generic quantization integration (peft.utils.quantization_utils). Methods that call
+# resolve_quantization_backend don't need per-backend integration modules; they support everything the resolver
+# handles (merging may still be unavailable for the forward-only backends, which is a property of the backend, not of
+# the PEFT method).
+GENERIC_QUANT_BACKENDS: tuple[str, ...] = (
+    "aqlm",
+    "awq",
+    "bnb_4bit",
+    "bnb_8bit",
+    "eetq",
+    "gptq",
+    "hqq",
+    "inc",
+    "torchao",
+)
+
+# Extra config arguments required to instantiate a method's config for probing, on top of the generic arguments
+# (target_modules for adapter methods, task_type/num_virtual_tokens for prompt learning). If probing a method reports
+# "unknown" because its config could not be instantiated, add an entry here.
+PROBE_CONFIG_OVERRIDES: dict[PeftType, dict[str, Any]] = {
+    # total_step is a required argument
+    PeftType.ADALORA: {"total_step": 10},
+    # IA3 needs feedforward_modules
+    PeftType.IA3: {"feedforward_modules": []},
+    # the default block_size of 256 does not divide HIDDEN_DIM
+    PeftType.C3A: {"block_size": 16},
+    # token_indices defaults to an empty list, which trains nothing
+    PeftType.TRAINABLE_TOKENS: {"token_indices": [0, 1]},
+    # the default vector_length of 256 does not divide HIDDEN_DIM
+    PeftType.VBLORA: {"num_vectors": 32, "vector_length": 16},
+    PeftType.ADAPTION_PROMPT: {"adapter_layers": 1, "adapter_len": 4, "task_type": "CAUSAL_LM"},
+}
+
+# Methods that cannot be probed on a self-contained tiny model. Probe-based checks report "unknown" for these.
+PROBE_SKIP: dict[PeftType, str] = {
+    PeftType.XLORA: "requires pre-trained LoRA adapter checkpoints to instantiate",
+}
+
+# Method-specific config switches that are worth surfacing as "extras". This is a curated list: reporting every config
+# field would drown the relevant information in noise. Note that target_parameters is not listed here, as it is
+# already covered by the target_layer_types check.
+NOTABLE_CONFIG_FIELDS: tuple[str, ...] = (
+    "alpha_pattern",
+    "layer_replication",
+    "rank_pattern",
+    "use_dora",
+    "use_rslora",
+)
+
+# Docs page slugs that differ from the lower-cased PEFT method name.
+DOCS_SLUG_OVERRIDES: dict[str, str] = {
+    "ADAPTION_PROMPT": "llama_adapter",
+    "CARTRIDGE": "cartridges",
+    "LN_TUNING": "layernorm_tuning",
+}
+
+# paper links as they appear in the docs intro paragraphs and in the config/model class docstrings
+PAPER_URL_RE = re.compile(
+    r"https://(?:huggingface\.co/papers/|arxiv\.org/(?:abs|pdf)/|openreview\.net/forum\?id=)[^\s)\"'>]+"
+)
+
+
+class Source(enum.StrEnum):
+    INTROSPECTION = "introspection"
+    FILE_CHECK = "file_check"
+    PROBE = "probe"
+    ERROR = "error"
+
+
+@dataclass(frozen=True)
+class Finding:
+    value: Any
+    source: Source
+    note: str | None = None
+
+    def to_json(self) -> dict[str, Any]:
+        result: dict[str, Any] = {"value": self.value, "source": str(self.source)}
+        if self.note:
+            result["note"] = self.note
+        return result
+
+
+@dataclass(frozen=True)
+class MethodInfo:
+    peft_type: PeftType
+    config_cls: type[PeftConfig]
+    model_cls: type | None
+    category: str  # "adapter", "prompt_learning", or "other"
+
+    @property
+    def name(self) -> str:
+        return self.peft_type.value
+
+    @classmethod
+    def from_peft_type(cls, peft_type: PeftType) -> "MethodInfo":
+        config_cls = PEFT_TYPE_TO_CONFIG_MAPPING[peft_type]
+        model_cls = PEFT_TYPE_TO_TUNER_MAPPING.get(peft_type)
+        if issubclass(config_cls, PromptLearningConfig):
+            category = "prompt_learning"
+        elif (model_cls is not None) and issubclass(model_cls, BaseTuner):
+            category = "adapter"
+        else:
+            # e.g. adaption prompt, whose model class manages adapters without subclassing BaseTuner
+            category = "other"
+        return cls(peft_type=peft_type, config_cls=config_cls, model_cls=model_cls, category=category)
+
+
+def _layer_classes(method: MethodInfo) -> list[type[BaseTunerLayer]]:
+    """Return the tuner layer classes defined in the method's main layer module.
+
+    Quantization-specific layer variants (bnb.py etc.) are deliberately not considered: importing them depends on the
+    installed quantization libraries, and the main layer module is what determines baseline support.
+    """
+    tuner_layer_cls = getattr(method.model_cls, "tuner_layer_cls", None)
+    if tuner_layer_cls is None:
+        return []
+    module = sys.modules[tuner_layer_cls.__module__]
+    return [
+        obj
+        for obj in vars(module).values()
+        if isinstance(obj, type) and issubclass(obj, BaseTunerLayer) and obj.__module__ == module.__name__
+    ]
+
+
+def _format_exception(exc: BaseException, limit: int = 250) -> str:
+    msg = f"{type(exc).__name__}: {exc}"
+    return msg if len(msg) <= limit else msg[: limit - 3] + "..."
+
+
+class ProbeError(Exception):
+    """Raised when a probe cannot be set up; results in an 'unknown' finding, never in a false positive/negative."""
+
+
+class SingleLayerModel(nn.Module):
+    """Minimal host model providing a single named module ("layer") for PEFT to target."""
+
+    def __init__(self, layer: nn.Module) -> None:
+        super().__init__()
+        self.layer = layer
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.layer(x)
+
+
+@dataclass(frozen=True)
+class LayerSpec:
+    label: str
+    build: Callable[[], nn.Module]
+
+
+# The layer types whose support is probed per method. Probing checks injection only (i.e. whether the layer gets
+# wrapped), no forward pass, since a successful wrap is the support signal and a broken forward would be a bug.
+LAYER_SPECS: tuple[LayerSpec, ...] = (
+    LayerSpec("Linear", lambda: nn.Linear(HIDDEN_DIM, HIDDEN_DIM)),
+    LayerSpec("Embedding", lambda: nn.Embedding(16, HIDDEN_DIM)),
+    LayerSpec("Conv1d", lambda: nn.Conv1d(HIDDEN_DIM, HIDDEN_DIM, 3)),
+    LayerSpec("Conv2d", lambda: nn.Conv2d(HIDDEN_DIM, HIDDEN_DIM, 3)),
+    LayerSpec("Conv3d", lambda: nn.Conv3d(HIDDEN_DIM, HIDDEN_DIM, 3)),
+    LayerSpec("LayerNorm", lambda: nn.LayerNorm(HIDDEN_DIM)),
+    LayerSpec("MultiheadAttention", lambda: nn.MultiheadAttention(HIDDEN_DIM, num_heads=4)),
+    LayerSpec("Conv1D (transformers)", lambda: Conv1D(HIDDEN_DIM, HIDDEN_DIM)),
+)
+
+
+class ProbeContext:
+    """Builds tiny throwaway models to exercise features on CPU.
+
+    The tiny transformer used for prompt learning methods is constructed from a config (no download) and cached; each
+    probe receives a deepcopy so that probes cannot contaminate each other.
+    """
+
+    def __init__(self) -> None:
+        self._tiny_lm: nn.Module | None = None
+
+    def make_config(self, method: MethodInfo, **kwargs: Any) -> PeftConfig:
+        if method.peft_type in PROBE_SKIP:
+            raise ProbeError(f"not probed: {PROBE_SKIP[method.peft_type]}")
+        kwargs = PROBE_CONFIG_OVERRIDES.get(method.peft_type, {}) | kwargs
+        try:
+            return method.config_cls(**kwargs)
+        except Exception as exc:
+            raise ProbeError(
+                f"could not instantiate {method.config_cls.__name__} for probing "
+                f"(consider adding an entry to PROBE_CONFIG_OVERRIDES): {_format_exception(exc)}"
+            ) from exc
+
+    def _probe_layer_and_input(self, method: MethodInfo) -> tuple[nn.Module, torch.Tensor]:
+        if method.peft_type == PeftType.TRAINABLE_TOKENS:
+            # trainable tokens only target embedding layers
+            return nn.Embedding(16, HIDDEN_DIM), torch.randint(0, 16, (2, 5))
+        return nn.Linear(HIDDEN_DIM, HIDDEN_DIM), torch.randn(2, HIDDEN_DIM)
+
+    def adapter_model(self, method: MethodInfo) -> tuple[nn.Module, torch.Tensor]:
+        """Return a PEFT model wrapping a single-layer host, plus a suitable example input."""
+        torch.manual_seed(0)
+        layer, example_input = self._probe_layer_and_input(method)
+        host = SingleLayerModel(layer)
+        config = self.make_config(method, target_modules=["layer"])
+        try:
+            return get_peft_model(host, config), example_input
+        except Exception as exc:
+            raise ProbeError(f"could not build probe model: {_format_exception(exc)}") from exc
+
+    def transformer_model(self, method: MethodInfo) -> nn.Module:
+        """Return a PEFT model on a tiny transformer, for methods that require one (prompt learning etc.)."""
+        if self._tiny_lm is None:
+            torch.manual_seed(0)
+            tiny_config = LlamaConfig(
+                vocab_size=64,
+                hidden_size=32,
+                intermediate_size=64,
+                num_hidden_layers=2,
+                num_attention_heads=4,
+                num_key_value_heads=4,
+                max_position_embeddings=64,
+            )
+            self._tiny_lm = LlamaForCausalLM(tiny_config)
+        kwargs: dict[str, Any] = {"task_type": "CAUSAL_LM"}
+        if method.category == "prompt_learning":
+            kwargs["num_virtual_tokens"] = 4
+        config = self.make_config(method, **kwargs)
+        try:
+            return get_peft_model(deepcopy(self._tiny_lm), config)
+        except Exception as exc:
+            raise ProbeError(f"could not build probe model: {_format_exception(exc)}") from exc
+
+    def second_config(self, method: MethodInfo) -> PeftConfig:
+        """A config suitable for adding a second adapter to a model built by this context."""
+        if method.category == "adapter":
+            return self.make_config(method, target_modules=["layer"])
+        kwargs: dict[str, Any] = {"task_type": "CAUSAL_LM"}
+        if method.category == "prompt_learning":
+            kwargs["num_virtual_tokens"] = 4
+        return self.make_config(method, **kwargs)
+
+
+class Task(ABC):
+    """A single feature check for a single method. Never raises; failures become 'unknown' findings."""
+
+    feature: ClassVar[str]
+    description: ClassVar[str]
+
+    def __init__(self, method: MethodInfo, probe: ProbeContext) -> None:
+        self.method = method
+        self.probe = probe
+
+    @abstractmethod
+    def check(self) -> Finding: ...
+
+    def run(self) -> Finding:
+        try:
+            # Probing emits plenty of warnings that are expected and irrelevant here (e.g. about adapter
+            # initialization or fan_in_fan_out). Suppression is re-asserted per task instead of once globally, since
+            # libraries imported lazily during probing may manipulate the global warning filters.
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore")
+                return self.check()
+        except ProbeError as exc:
+            return Finding(value=UNKNOWN, source=Source.PROBE, note=str(exc))
+        except Exception as exc:
+            return Finding(value=UNKNOWN, source=Source.ERROR, note=_format_exception(exc))
+
+
+class CategoryTask(Task):
+    feature = "category"
+    description = "whether the method is a layer-wrapping adapter, a prompt learning method, or something else"
+
+    def check(self) -> Finding:
+        return Finding(value=self.method.category, source=Source.INTROSPECTION)
+
+
+class TargetLayerTypesTask(Task):
+    feature = "target_layer_types"
+    description = (
+        "which layer types (incl. nn.Parameter) can be targeted, probed by injecting into single-layer models"
+    )
+
+    def check(self) -> Finding:
+        if self.method.category != "adapter":
+            return Finding(
+                value=NOT_APPLICABLE, source=Source.INTROSPECTION, note="method does not wrap target layers"
+            )
+
+        results: dict[str, bool] = {}
+        first_error: str | None = None
+        for spec in LAYER_SPECS:
+            torch.manual_seed(0)
+            host = SingleLayerModel(spec.build())
+            config = self.probe.make_config(self.method, target_modules=["layer"])
+            try:
+                model = get_peft_model(host, config)
+            except Exception as exc:
+                results[spec.label] = False
+                if first_error is None:
+                    first_error = f"{spec.label}: {_format_exception(exc)}"
+            else:
+                results[spec.label] = any(isinstance(module, BaseTunerLayer) for module in model.modules())
+
+        if not any(results.values()):
+            # if not even one layer type can be wrapped, the probe setup is likely at fault, not the method
+            raise ProbeError(f"no layer type could be wrapped, probe presumably mis-configured; {first_error}")
+
+        # Directly targeting nn.Parameter (crucial e.g. for MoE layers) is governed by the target_parameters config
+        # option; its presence is the support signal, no injection probe is needed.
+        field_names = {f.name for f in dataclasses.fields(self.method.config_cls)}
+        results["nn.Parameter"] = "target_parameters" in field_names
+        return Finding(
+            value=results,
+            source=Source.PROBE,
+            note="nn.Parameter support is based on the presence of the target_parameters config option",
+        )
+
+
+class QuantizationTask(Task):
+    feature = "quantization_backends"
+    description = "supported quantization backends, from integration modules and use of the generic backend resolver"
+
+    def check(self) -> Finding:
+        if self.method.category == "prompt_learning":
+            return Finding(
+                value=NOT_APPLICABLE,
+                source=Source.INTROSPECTION,
+                note="prompt learning does not wrap target layers and generally works regardless of quantization",
+            )
+        if self.method.category != "adapter":
+            return Finding(value=UNKNOWN, source=Source.INTROSPECTION, note="no known quantization signal")
+
+        backends: set[str] = set()
+        package_dir = Path(inspect.getfile(self.method.model_cls)).parent
+        for stem, names in QUANT_FILE_BACKENDS.items():
+            if (package_dir / f"{stem}.py").exists():
+                backends.update(names)
+
+        # methods using the generic quantization integration support all backends the resolver handles
+        module_names = {self.method.model_cls.__module__}
+        if (tuner_layer_cls := getattr(self.method.model_cls, "tuner_layer_cls", None)) is not None:
+            module_names.add(tuner_layer_cls.__module__)
+        for module_name in module_names:
+            if "resolve_quantization_backend" in inspect.getsource(sys.modules[module_name]):
+                backends.update(GENERIC_QUANT_BACKENDS)
+                break
+
+        return Finding(value=sorted(backends), source=Source.FILE_CHECK)
+
+
+class MultipleAdaptersTask(Task):
+    feature = "multiple_adapters"
+    description = "whether several adapters can be loaded on the same model, probed via add_adapter"
+
+    def check(self) -> Finding:
+        if self.method.category == "adapter":
+            model, _ = self.probe.adapter_model(self.method)
+        else:
+            model = self.probe.transformer_model(self.method)
+        try:
+            model.add_adapter("second", self.probe.second_config(self.method))
+            model.set_adapter("second")
+        except Exception as exc:
+            return Finding(value=False, source=Source.PROBE, note=_format_exception(exc))
+        return Finding(value=True, source=Source.PROBE)
+
+
+class MixedAdapterBatchesTask(Task):
+    feature = "mixed_adapter_batches"
+    description = "whether one batch can mix several adapters via the adapter_names argument"
+
+    def check(self) -> Finding:
+        if self.method.category != "adapter":
+            return Finding(
+                value=False, source=Source.INTROSPECTION, note="only supported by layer-wrapping adapter methods"
+            )
+        # Support requires both halves of the mechanism: the model must install the forward hooks that distribute
+        # adapter_names, and the tuner layers must implement _mixed_batch_forward (possibly inherited, e.g. from
+        # LoRA). Checking only one of them would over-report.
+        model_supports_hooks = hasattr(self.method.model_cls, "_enable_peft_forward_hooks")
+        layer_classes = _layer_classes(self.method)
+        layer_supports = any(hasattr(cls, "_mixed_batch_forward") for cls in layer_classes)
+        return Finding(value=model_supports_hooks and layer_supports, source=Source.INTROSPECTION)
+
+
+class MergeTask(Task):
+    feature = "merging"
+    description = "whether adapters can be merged into the base weights, verified via merge_and_unload"
+
+    def check(self) -> Finding:
+        if self.method.category == "prompt_learning":
+            return Finding(
+                value=False, source=Source.INTROSPECTION, note="virtual tokens cannot be merged into base weights"
+            )
+        if self.method.category != "adapter":
+            return Finding(value=False, source=Source.INTROSPECTION, note="method does not implement merging")
+
+        layer_classes = _layer_classes(self.method)
+        # BaseTunerLayer.merge raises NotImplementedError, so an unchanged merge attribute means no support
+        implemented = any(cls.merge is not BaseTunerLayer.merge for cls in layer_classes)
+        if not implemented:
+            return Finding(value=False, source=Source.INTROSPECTION, note="no tuner layer class implements merge()")
+
+        try:
+            model, example_input = self.probe.adapter_model(self.method)
+            model.eval()
+            with torch.no_grad():
+                output_before = model(example_input)
+                merged = model.merge_and_unload()
+                output_after = merged(example_input)
+        except ProbeError as exc:
+            return Finding(
+                value=True, source=Source.INTROSPECTION, note=f"merge() is implemented, but probing failed: {exc}"
+            )
+        except NotImplementedError as exc:
+            return Finding(value=False, source=Source.PROBE, note=_format_exception(exc))
+        except Exception as exc:
+            return Finding(
+                value=True,
+                source=Source.INTROSPECTION,
+                note=f"merge() is implemented, but probing failed: {_format_exception(exc)}",
+            )
+
+        note = None
+        if not torch.allclose(output_before, output_after, atol=1e-4):
+            note = "merged model outputs deviate from unmerged outputs beyond tolerance"
+        return Finding(value=True, source=Source.PROBE, note=note)
+
+
+class MixedMethodModelTask(Task):
+    feature = "peft_mixed_model"
+    description = "whether the method can be combined with other method types in a PeftMixedModel"
+
+    def check(self) -> Finding:
+        # filled by register_peft_method(..., is_mixed_compatible=True)
+        value = self.method.peft_type in PEFT_TYPE_TO_MIXED_MODEL_MAPPING
+        return Finding(value=value, source=Source.INTROSPECTION)
+
+
+class LoraConversionTask(Task):
+    feature = "lora_conversion"
+    description = "whether adapters of this method can be converted to a LoRA adapter"
+
+    def check(self) -> Finding:
+        if self.method.peft_type == PeftType.LORA:
+            return Finding(value=True, source=Source.INTROSPECTION, note="already a LoRA adapter")
+        if self.method.category != "adapter":
+            return Finding(value=False, source=Source.INTROSPECTION, note="method does not wrap target layers")
+
+        try:
+            model, _ = self.probe.adapter_model(self.method)
+        except ProbeError as exc:
+            # fall back to a static signal; an override does not guarantee support, hence the note
+            layer_classes = _layer_classes(self.method)
+            overridden = any(
+                cls.supports_lora_conversion is not BaseTunerLayer.supports_lora_conversion for cls in layer_classes
+            )
+            return Finding(
+                value=overridden,
+                source=Source.INTROSPECTION,
+                note=f"based on presence of a supports_lora_conversion override; probing failed: {exc}",
+            )
+
+        layer = next(module for module in model.modules() if isinstance(module, BaseTunerLayer))
+        return Finding(value=bool(layer.supports_lora_conversion("default")), source=Source.PROBE)
+
+
+class WeightedAdapterTask(Task):
+    feature = "add_weighted_adapter"
+    description = "whether several adapters can be combined into a new one, probed via add_weighted_adapter"
+
+    def check(self) -> Finding:
+        # Methods without the API don't support the feature; methods that inherit it but override it with a stub
+        # that raises (e.g. AdaLoRA) are caught by the probe below.
+        if getattr(self.method.model_cls, "add_weighted_adapter", None) is None:
+            return Finding(value=False, source=Source.INTROSPECTION)
+
+        model, _ = self.probe.adapter_model(self.method)
+        # combining several adapters requires loading several adapters in the first place; methods that already fail
+        # here cannot support add_weighted_adapter either
+        try:
+            model.add_adapter("second", self.probe.second_config(self.method))
+        except Exception as exc:
+            return Finding(
+                value=False,
+                source=Source.PROBE,
+                note=f"a second adapter could not be added: {_format_exception(exc)}",
+            )
+        try:
+            model.add_weighted_adapter(adapters=["default", "second"], weights=[0.5, 0.5], adapter_name="combined")
+        except Exception as exc:
+            return Finding(value=False, source=Source.PROBE, note=_format_exception(exc))
+        return Finding(value=True, source=Source.PROBE)
+
+
+class HotswapTask(Task):
+    feature = "hotswapping"
+    description = "whether adapters can be hot-swapped in place (peft.utils.hotswap)"
+
+    def check(self) -> Finding:
+        return Finding(value=self.method.peft_type in CONFIG_KEYS_TO_CHECK, source=Source.INTROSPECTION)
+
+
+class AuxiliaryModulesTask(Task):
+    feature = "auxiliary_modules"
+    description = "whether the config supports modules_to_save and trainable_token_indices"
+
+    def check(self) -> Finding:
+        field_names = {f.name for f in dataclasses.fields(self.method.config_cls)}
+        value = {
+            "modules_to_save": "modules_to_save" in field_names,
+            "trainable_token_indices": "trainable_token_indices" in field_names,
+        }
+        return Finding(value=value, source=Source.INTROSPECTION)
+
+
+class ExtrasTask(Task):
+    feature = "extras"
+    description = "notable method-specific config options (curated list)"
+
+    def check(self) -> Finding:
+        field_names = {f.name for f in dataclasses.fields(self.method.config_cls)}
+        value = sorted(field_names.intersection(NOTABLE_CONFIG_FIELDS))
+        return Finding(value=value, source=Source.INTROSPECTION)
+
+
+class PaperLinkTask(Task):
+    feature = "paper_url"
+    description = "link to the method's paper, from the docs intro or class docstrings (omitted when ambiguous)"
+
+    # default assumes the script lives in scripts/ of a repository checkout; can be overridden via --docs-dir
+    docs_dir: ClassVar[Path] = Path(__file__).parent.parent / "docs" / "source" / "package_reference"
+
+    def _docs_intro(self) -> str | None:
+        """The first paragraph after the first heading of the method's docs page (the pages start with a license
+        comment, a `# Title` heading, and a prose paragraph)."""
+        slug = DOCS_SLUG_OVERRIDES.get(self.method.name, self.method.name.lower())
+        try:
+            text = (self.docs_dir / f"{slug}.md").read_text()
+        except OSError:
+            return None
+        text = re.sub(r"<!--.*?-->", "", text, flags=re.DOTALL)
+        match = re.search(r"^# .+?$\s+(.+?)(?:\n\s*\n|$)", text, flags=re.MULTILINE | re.DOTALL)
+        return match.group(1) if match else None
+
+    def check(self) -> Finding:
+        # Sources in order of preference; the first one containing exactly one distinct paper URL wins. A source
+        # with no link, or with several different ones (e.g. docstrings that also cite related methods), is skipped
+        # as ambiguous -- a missing paper link is better than a wrong one.
+        sources: list[tuple[str, str | None]] = [
+            ("docs intro", self._docs_intro()),
+            ("config class docstring", self.method.config_cls.__doc__),
+            ("model class docstring", self.method.model_cls.__doc__ if self.method.model_cls is not None else None),
+        ]
+        for source_name, text in sources:
+            if not text:
+                continue
+            urls = set(PAPER_URL_RE.findall(text))
+            if len(urls) == 1:
+                return Finding(value=urls.pop(), source=Source.FILE_CHECK, note=f"from the {source_name}")
+        return Finding(
+            value=None,
+            source=Source.FILE_CHECK,
+            note="no unambiguous paper link in the docs intro or the config/model class docstrings",
+        )
+
+
+# the order here determines the order of the features in the output
+TASK_CLASSES: tuple[type[Task], ...] = (
+    CategoryTask,
+    TargetLayerTypesTask,
+    QuantizationTask,
+    MultipleAdaptersTask,
+    MixedAdapterBatchesTask,
+    MergeTask,
+    MixedMethodModelTask,
+    LoraConversionTask,
+    WeightedAdapterTask,
+    HotswapTask,
+    AuxiliaryModulesTask,
+    ExtrasTask,
+    PaperLinkTask,
+)
+
+
+def collect_methods(selected: list[str] | None) -> list[MethodInfo]:
+    registered = sorted(PEFT_TYPE_TO_CONFIG_MAPPING, key=lambda peft_type: peft_type.value)
+    if selected is not None:
+        valid = {peft_type.value for peft_type in registered}
+        requested = [name.upper() for name in selected]
+        if unknown := [name for name in requested if name not in valid]:
+            raise SystemExit(
+                f"Unknown PEFT method(s): {', '.join(unknown)}. Valid choices: {', '.join(sorted(valid))}"
+            )
+        registered = [peft_type for peft_type in registered if peft_type.value in requested]
+    return [MethodInfo.from_peft_type(peft_type) for peft_type in registered]
+
+
+def collect_tasks(methods: list[MethodInfo], probe: ProbeContext) -> list[Task]:
+    return [task_cls(method, probe) for method in methods for task_cls in TASK_CLASSES]
+
+
+def run_tasks(tasks: list[Task]) -> dict[str, dict[str, Any]]:
+    results: dict[str, dict[str, Any]] = {}
+    for task in tqdm(tasks, desc="Checking capabilities", unit="check"):
+        method = task.method
+        entry = results.setdefault(
+            method.name,
+            {
+                "config_class": method.config_cls.__name__,
+                "model_class": method.model_cls.__name__ if method.model_cls is not None else None,
+                "features": {},
+            },
+        )
+        entry["features"][task.feature] = task.run().to_json()
+    return results
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(
+        description="Generate a JSON capability matrix of all PEFT methods.",
+        epilog="Example: python scripts/generate_method_capabilities.py --methods lora ia3 --output capabilities.json",
+    )
+    parser.add_argument(
+        "--methods",
+        "-m",
+        nargs="+",
+        default=None,
+        metavar="METHOD",
+        help="restrict the analysis to these PEFT methods (case-insensitive, e.g. 'lora ia3'); default: all",
+    )
+    parser.add_argument(
+        "--output",
+        "-o",
+        type=Path,
+        default=Path("method_capabilities.json"),
+        help="output JSON file (default: %(default)s)",
+    )
+    parser.add_argument("--dry-run", action="store_true", help="only list the checks that would run")
+    parser.add_argument(
+        "--docs-dir",
+        type=Path,
+        default=PaperLinkTask.docs_dir,
+        help="directory containing the package_reference docs pages, used for the paper link check",
+    )
+    args = parser.parse_args(argv)
+    PaperLinkTask.docs_dir = args.docs_dir
+    logging.basicConfig(level=logging.INFO, format="%(message)s")  # logs to stderr
+
+    methods = collect_methods(args.methods)
+    probe = ProbeContext()
+    tasks = collect_tasks(methods, probe)
+
+    if args.dry_run:
+        for method in methods:
+            print(f"{method.name}: {', '.join(task_cls.feature for task_cls in TASK_CLASSES)}")
+        print(f"\n{len(methods)} methods x {len(TASK_CLASSES)} checks = {len(tasks)} tasks")
+        return
+
+    output = {
+        "schema_version": 1,
+        "peft_version": peft.__version__,
+        "methods": run_tasks(tasks),
+    }
+    # The results deliberately go to a file, not to stdout: probing can trigger subprocesses whose output is written
+    # directly to stdout (e.g. BOFT compiling its CUDA extension via ninja), which would interleave with the JSON.
+    args.output.write_text(json.dumps(output, indent=2) + "\n")
+    logger.info(f"Wrote capabilities of {len(methods)} methods to {args.output}")
+
+
+if __name__ == "__main__":
+    main()

tasks/tasksmith-c488fc138ba1/environment/source/scripts/launch_notebook_mp.py

@@ -0,0 +1,47 @@
+# Copyright 2023-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# This is a minimal example of launching PEFT with Accelerate. This used to cause issues because PEFT would eagerly
+# import bitsandbytes, which initializes CUDA, resulting in:
+# > RuntimeError: Cannot re-initialize CUDA in forked subprocess. To use CUDA with multiprocessing, you must use the
+# > 'spawn' start method
+# This script exists to ensure that this issue does not reoccur.
+
+import torch
+from accelerate import notebook_launcher
+
+import peft
+from peft.utils import infer_device
+
+
+def init():
+    class MyModule(torch.nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.linear = torch.nn.Linear(1, 2)
+
+        def forward(self, x):
+            return self.linear(x)
+
+    device = infer_device()
+    model = MyModule().to(device)
+    peft.get_peft_model(model, peft.LoraConfig(target_modules=["linear"]))
+
+
+def main():
+    notebook_launcher(init, (), num_processes=2)
+
+
+if __name__ == "__main__":
+    main()

tasks/tasksmith-c488fc138ba1/environment/source/scripts/log_reports.py

@@ -0,0 +1,144 @@
+import argparse
+import json
+import os
+from datetime import UTC, datetime
+from pathlib import Path
+
+from tabulate import tabulate
+
+
+MAX_LEN_MESSAGE = 2900  # slack endpoint has a limit of 3001 characters
+
+parser = argparse.ArgumentParser()
+parser.add_argument(
+    "--slack_channel_name",
+    default="peft-ci-daily",
+)
+
+
+def main(slack_channel_name=None):
+    failed = []
+    passed = []
+
+    group_info = []
+
+    total_num_failed = 0
+    empty_file = False or len(list(Path().glob("*.log"))) == 0
+
+    total_empty_files = []
+
+    for log in Path().glob("*.log"):
+        section_num_failed = 0
+        i = 0
+        with open(log) as f:
+            for line in f:
+                line = json.loads(line)
+                i += 1
+                if line.get("nodeid", "") != "":
+                    test = line["nodeid"]
+                    if line.get("duration", None) is not None:
+                        duration = f"{line['duration']:.4f}"
+                        if line.get("outcome", "") == "failed":
+                            section_num_failed += 1
+                            failed.append([test, duration, log.name.split("_")[0]])
+                            total_num_failed += 1
+                        else:
+                            passed.append([test, duration, log.name.split("_")[0]])
+            empty_file = i == 0
+        group_info.append([str(log), section_num_failed, failed])
+        total_empty_files.append(empty_file)
+        os.remove(log)
+        failed = []
+    text = (
+        "🌞 There were no failures!"
+        if not any(total_empty_files)
+        else "Something went wrong there is at least one empty file - please check GH action results."
+    )
+    no_error_payload = {
+        "type": "section",
+        "text": {
+            "type": "plain_text",
+            "text": text,
+            "emoji": True,
+        },
+    }
+
+    message = ""
+    payload = [
+        {
+            "type": "header",
+            "text": {
+                "type": "plain_text",
+                "text": "🤗 Results of the {} PEFT scheduled tests.".format(os.environ.get("TEST_TYPE", "")),
+            },
+        },
+    ]
+    if total_num_failed > 0:
+        for i, (name, num_failed, failed_tests) in enumerate(group_info):
+            if num_failed > 0:
+                if num_failed == 1:
+                    message += f"*{name}: {num_failed} failed test*\n"
+                else:
+                    message += f"*{name}: {num_failed} failed tests*\n"
+                failed_table = []
+                for test in failed_tests:
+                    failed_table.append(test[0].split("::"))
+                failed_table = tabulate(
+                    failed_table,
+                    headers=["Test Location", "Test Case", "Test Name"],
+                    showindex="always",
+                    tablefmt="grid",
+                    maxcolwidths=[12, 12, 12],
+                )
+                message += "\n```\n" + failed_table + "\n```"
+
+            if total_empty_files[i]:
+                message += f"\n*{name}: Warning! Empty file - please check the GitHub action job *\n"
+        print(f"### {message}")
+    else:
+        payload.append(no_error_payload)
+
+    if os.environ.get("TEST_TYPE", "") != "":
+        from slack_sdk import WebClient
+
+        if len(message) > MAX_LEN_MESSAGE:
+            print(f"Truncating long message from {len(message)} to {MAX_LEN_MESSAGE}")
+            message = message[:MAX_LEN_MESSAGE] + "..."
+
+        if len(message) != 0:
+            md_report = {
+                "type": "section",
+                "text": {"type": "mrkdwn", "text": message},
+            }
+            payload.append(md_report)
+            action_button = {
+                "type": "section",
+                "text": {"type": "mrkdwn", "text": "*For more details:*"},
+                "accessory": {
+                    "type": "button",
+                    "text": {"type": "plain_text", "text": "Check Action results", "emoji": True},
+                    "url": f"https://github.com/huggingface/peft/actions/runs/{os.environ['GITHUB_RUN_ID']}",
+                },
+            }
+            payload.append(action_button)
+
+        date_report = {
+            "type": "context",
+            "elements": [
+                {
+                    "type": "plain_text",
+                    "text": f"Nightly {os.environ.get('TEST_TYPE')} test results for {datetime.now(UTC).date()}",
+                },
+            ],
+        }
+        payload.append(date_report)
+
+        print(payload)
+
+        client = WebClient(token=os.environ.get("SLACK_API_TOKEN"))
+        client.chat_postMessage(channel=f"#{slack_channel_name}", text=message, blocks=payload)
+
+
+if __name__ == "__main__":
+    args = parser.parse_args()
+    main(args.slack_channel_name)

tasks/tasksmith-c488fc138ba1/environment/source/scripts/stale.py

@@ -0,0 +1,65 @@
+# Copyright 2023 The HuggingFace Team, the AllenNLP library authors. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Script to close stale issue. Taken in part from the AllenNLP repository.
+https://github.com/allenai/allennlp.
+"""
+
+import os
+from datetime import datetime as dt
+from datetime import timezone
+
+from github import Github
+
+
+LABELS_TO_EXEMPT = [
+    "good first issue",
+    "good second issue",
+    "good difficult issue",
+    "feature request",
+    "new model",
+    "wip",
+    "PRs welcome to address this",
+]
+
+
+def main():
+    g = Github(os.environ["GITHUB_TOKEN"])
+    repo = g.get_repo("huggingface/peft")
+    open_issues = repo.get_issues(state="open")
+
+    for issue in open_issues:
+        comments = sorted(issue.get_comments(), key=lambda i: i.created_at, reverse=True)
+        last_comment = comments[0] if len(comments) > 0 else None
+        if (
+            (last_comment is not None and last_comment.user.login == "github-actions[bot]")
+            and (dt.now(timezone.utc) - issue.updated_at).days > 7
+            and (dt.now(timezone.utc) - issue.created_at).days >= 30
+            and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels())
+        ):
+            issue.edit(state="closed")
+        elif (
+            (dt.now(timezone.utc) - issue.updated_at).days > 23
+            and (dt.now(timezone.utc) - issue.created_at).days >= 30
+            and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels())
+        ):
+            issue.create_comment(
+                "This issue has been automatically marked as stale because it has not had "
+                "recent activity. If you think this still needs to be addressed "
+                "please comment on this thread.\n\n"
+            )
+
+
+if __name__ == "__main__":
+    main()

tasks/tasksmith-c488fc138ba1/environment/source/scripts/train_memory.py

@@ -0,0 +1,276 @@
+# Copyright 2025-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""This script trains a model on a small text dataset and measures the memory consumption, as well as a few other
+useful metrics.
+
+Example:
+
+Get help:
+
+```bash
+python train_memory.py --help
+```
+
+Train the google/gemma-2-2b model with a LoRA config json at the indicated location.
+
+```bash
+python train_memory.py "google/gemma-2-2b" --max_seq_length 256 --batch_size 1 --rank 32 --dtype bfloat16 --path_config <path-to-adapter-config.json>
+```
+
+Fully fine-tune the model (i.e. without LoRA) by setting the rank to 0:
+
+```bash
+python train_memory.py "google/gemma-2-2b" --rank 0
+```
+
+Get an estimate of the size of the hidden states by passing `--monitor_tensors`. This trains just for a single epoch. For realistic estimates, the batch size for this:
+
+```bash
+python train_memory.py "google/gemma-2-2b" --max_seq_length 256 --batch_size 32 --rank 32 --dtype bfloat16 --path_config configs/lora_rank-32_embedding-lora/ --monitor_tensors
+```
+
+"""
+
+import argparse
+import gc
+import os
+import sys
+import tempfile
+import time
+import warnings
+from collections import Counter
+from contextlib import nullcontext
+from functools import partial
+
+import torch
+from datasets import load_dataset
+from torch import nn
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    BitsAndBytesConfig,
+)
+
+from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
+from peft.utils import CONFIG_NAME, SAFETENSORS_WEIGHTS_NAME
+
+
+# suppress all warnings
+warnings.filterwarnings("ignore")
+
+device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+dtype_to_bytes_linear = {"float32": 4, "float16": 2, "bfloat16": 2, "int8": 1, "int4": 0.5}
+
+
+def init_accelerator():
+    torch.manual_seed(0)
+    if device == "cpu":
+        return
+
+    device_module = getattr(torch, device, torch.cuda)
+    device_module.reset_peak_memory_stats()
+    device_module.manual_seed_all(0)
+    # might not be necessary, but just to be sure
+    nn.Linear(1, 1).to(device)
+
+
+def get_data(tokenizer):
+    def tokenize(samples):
+        # For some reason, the max sequence length is not honored by the tokenizer, resulting in IndexErrors. Thus,
+        # manually ensure that sequences are not too long.
+        tokenized = tokenizer(samples["quote"])
+        tokenized["input_ids"] = [input_ids[: tokenizer.model_max_length] for input_ids in tokenized["input_ids"]]
+        tokenized["attention_mask"] = [
+            input_ids[: tokenizer.model_max_length] for input_ids in tokenized["attention_mask"]
+        ]
+        return tokenized
+
+    data = load_dataset("ybelkada/english_quotes_copy")
+    data = data.map(tokenize, batched=True)
+    # We need to manually remove unused columns. This is because we cannot use remove_unused_columns=True in the
+    # Trainer, as this leads to errors with torch.compile. We also cannot just leave them in, as they contain
+    # strings. Therefore, manually remove all unused columns.
+    data = data.remove_columns(["quote", "author", "tags"])
+    return data
+
+
+def train(model_id, rank, dtype, monitor_tensors, max_seq_length, batch_size, max_steps, path_config):
+    init_accelerator()
+    device_module = getattr(torch, device, torch.cuda)
+    accelerator_memory_init = device_module.max_memory_allocated()
+    accelerator_memory_log = []
+
+    tokenizer = AutoTokenizer.from_pretrained(model_id)
+    tokenizer.model_max_length = max_seq_length
+    if not tokenizer.pad_token:
+        tokenizer.pad_token = tokenizer.eos_token
+    data = get_data(tokenizer)
+
+    if dtype == "int4":
+        quant_config = BitsAndBytesConfig(load_in_4bit=True)
+        model = AutoModelForCausalLM.from_pretrained(model_id, device_map=device, quantization_config=quant_config)
+        model = prepare_model_for_kbit_training(model)
+    elif dtype == "int8":
+        quant_config = BitsAndBytesConfig(load_in_8bit=True)
+        model = AutoModelForCausalLM.from_pretrained(model_id, device_map=device, quantization_config=quant_config)
+        model = prepare_model_for_kbit_training(model)
+    elif dtype == "bfloat16":
+        model = AutoModelForCausalLM.from_pretrained(model_id, device_map=device, torch_dtype=torch.bfloat16)
+    elif dtype == "float16":
+        model = AutoModelForCausalLM.from_pretrained(model_id, device_map=device, torch_dtype=torch.float16)
+    elif dtype == "float32":
+        model = AutoModelForCausalLM.from_pretrained(model_id, device_map=device)
+    else:
+        raise ValueError(f"Invalid dtype: {dtype}")
+
+    if rank > 0:
+        if path_config is None:
+            raise RuntimeError("LoRA rank > 0 requires a path to a LoRA config")
+        if path_config.endswith(CONFIG_NAME):
+            path_config = path_config.removesuffix(CONFIG_NAME)
+        config = LoraConfig.from_pretrained(path_config)
+        model = get_peft_model(model, config)
+        model.print_trainable_parameters()
+    else:
+        print("Not using LoRA")
+
+    model.config.use_cache = False
+    storage = []
+
+    def pack(x):
+        storage.append(x)
+        return len(storage) - 1
+
+    def unpack(x):
+        return storage[x]
+
+    train_ctx = partial(torch.autograd.graph.saved_tensors_hooks, pack, unpack) if monitor_tensors else nullcontext
+
+    optimizer = torch.optim.AdamW(model.parameters(), lr=1e-5)
+    losses = []
+    sample = 0
+    tic_total = time.perf_counter()
+    for i in range(max_steps):
+        storage.clear()
+        tic = time.perf_counter()
+        try:
+            batch = tokenizer.pad(data["train"][sample : sample + batch_size], return_tensors="pt").to(model.device)
+            sample += batch_size
+
+            # add targets
+            batch["labels"] = batch["input_ids"].clone()
+            optimizer.zero_grad()
+
+            with train_ctx():
+                outputs = model(**batch)
+            loss = outputs.loss
+            loss.backward()
+            optimizer.step()
+            losses.append(loss.item())
+            accelerator_memory_log.append(device_module.memory_allocated() - accelerator_memory_init)
+            device_module.empty_cache()
+            gc.collect()
+            toc = time.perf_counter()
+            print(f"step {i:3d} loss {loss.item():.6f} time {toc - tic:.2f}s", file=sys.stderr)
+        except KeyboardInterrupt:
+            print("canceled training")
+            break
+
+        if monitor_tensors:
+            break
+
+    toc_total = time.perf_counter()
+
+    accelerator_memory_final = device_module.max_memory_allocated()
+    accelerator_memory_avg = int(sum(accelerator_memory_log) / len(accelerator_memory_log))
+    print(f"{model.device.type} memory avg: {accelerator_memory_avg // 2**20}MB")
+    print(f"{model.device.type} memory max: {(accelerator_memory_final - accelerator_memory_init) // 2**20}MB")
+    print(f"total time: {toc_total - tic_total:.2f}s")
+
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        model.save_pretrained(tmp_dir)
+        stat = os.stat(os.path.join(tmp_dir, SAFETENSORS_WEIGHTS_NAME))
+    file_size = stat.st_size
+    print(f"file size: {file_size / 2**20:.1f}MB")
+
+    if monitor_tensors:
+        dtype_counts = Counter(t.dtype for t in storage)
+        shape_counts = Counter(t.shape for t in storage)
+        param_shape_counts = Counter(p.shape for p in model.parameters())
+        param_shape_counts_copy = dict(param_shape_counts).copy()
+
+        # shape counts includes the params, so we need to subtract them; note that they can be transposed
+        # this is an approximation
+        diff_shape_counts = {}
+        for shape, count in shape_counts.items():
+            if shape in param_shape_counts_copy:
+                diff_count = count - param_shape_counts[shape]
+                if diff_count > 0:
+                    diff_shape_counts[shape] = diff_count
+                    param_shape_counts_copy[shape] = max(0, param_shape_counts_copy[shape] - diff_count)
+            elif shape[::-1] in param_shape_counts:
+                diff_count = count - param_shape_counts[shape[::-1]]
+                if diff_count > 0:
+                    diff_shape_counts[shape] = diff_count
+                    param_shape_counts_copy[shape[::-1]] = max(0, param_shape_counts_copy[shape[::-1]] - diff_count)
+            else:
+                diff_shape_counts[shape] = count
+
+        total_size = sum(t.numel() * t.element_size() for t in storage)
+        total_size_mb = f"{total_size // 2**20}MB"
+        diff_size = 0
+        for shape, count in diff_shape_counts.items():
+            diff_size += count * torch.zeros(shape).numel() * dtype_to_bytes_linear[dtype]
+        param_size = total_size - diff_size
+
+        diff_size_mb = f"{diff_size // 2**20}MB"
+        param_size_mb = f"{param_size // 2**20}MB"
+
+        print(f"Dtype counts: {dtype_counts.most_common()}")
+        print(f"Total size of tensors:     {total_size_mb: >12}")
+        print(f"Total size of activations: {diff_size_mb: >12}")
+        print(f"Total size of parameters:  {param_size_mb: >12}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("model_id", type=str, help="Model name on Hugging Face Hub")
+    parser.add_argument("--rank", type=int, default=8, help="Rank of LoRA, 0 => no LoRA, default 8")
+    parser.add_argument(
+        "--dtype",
+        type=str,
+        default="float32",
+        help="Data type, one of float32, float16, bfloat16, int8, int4, default float32",
+    )
+    parser.add_argument(
+        "--monitor_tensors",
+        action="store_true",
+        help="Monitor tensor sizes during training for a single training step, off by default",
+    )
+    parser.add_argument("--max_seq_length", type=int, default=128, help="Maximum sequence length, default 128")
+    parser.add_argument("--batch_size", type=int, default=1, help="Batch size, default 1")
+    parser.add_argument("--max_steps", type=int, default=50, help="Maximum number of training steps, default 50")
+    parser.add_argument("--path_config", type=str, default=None, help="Path to LoRA config")
+    args = parser.parse_args()
+    train(
+        model_id=args.model_id,
+        rank=args.rank,
+        dtype=args.dtype,
+        monitor_tensors=args.monitor_tensors,
+        max_seq_length=args.max_seq_length,
+        batch_size=args.batch_size,
+        max_steps=args.max_steps,
+        path_config=args.path_config,
+    )

tasks/tasksmith-c488fc138ba1/environment/source/setup.py

@@ -0,0 +1,117 @@
+# Copyright 2023 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from setuptools import find_packages, setup
+
+
+VERSION = "0.19.2.dev0"
+
+extras = {}
+extras["quality"] = [
+    "black",  # doc-builder has an implicit dependency on Black, see huggingface/doc-builder#434
+    "hf-doc-builder",
+    # when upgrading this, also upgrade required version in pyproject.toml and pre-commit-config.yaml
+    "ruff~=0.15.12",
+]
+extras["docs_specific"] = [
+    "black",  # doc-builder has an implicit dependency on Black, see huggingface/doc-builder#434
+    "requests",  # doc-builder has an implicit dependency on requests (setup.py doesn't mention it, pyproject does)
+    "hf-doc-builder",
+]
+extras["dev"] = extras["quality"] + extras["docs_specific"]
+extras["test"] = extras["dev"] + [
+    "pytest",
+    "pytest-cov",
+    "pytest-xdist",
+    "parameterized",
+    "datasets",
+    "diffusers",
+    "scipy",
+    "scikit-learn",
+    "protobuf",
+    "sentencepiece",
+    "torchvision",
+]
+
+with open("README.md", encoding="utf-8") as f:
+    long_description = f.read()
+
+setup(
+    name="peft",
+    version=VERSION,
+    description="Parameter-Efficient Fine-Tuning (PEFT)",
+    license_files=["LICENSE"],
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    keywords="deep learning",
+    license="Apache",
+    author="The HuggingFace team",
+    author_email="benjamin@huggingface.co",
+    url="https://github.com/huggingface/peft",
+    package_dir={"": "src"},
+    packages=find_packages("src"),
+    package_data={"peft": ["py.typed", "tuners/boft/fbd/fbd_cuda.cpp", "tuners/boft/fbd/fbd_cuda_kernel.cu"]},
+    entry_points={},
+    python_requires=">=3.10.0",
+    install_requires=[
+        "numpy>=1.17",
+        "packaging>=20.0",
+        "psutil",
+        "pyyaml",
+        "torch>=1.13.0",
+        "transformers",
+        "tqdm",
+        "accelerate>=0.21.0",
+        "safetensors",
+        "huggingface_hub>=0.25.0",
+    ],
+    extras_require=extras,
+    classifiers=[
+        "Development Status :: 5 - Production/Stable",
+        "Intended Audience :: Developers",
+        "Intended Audience :: Education",
+        "Intended Audience :: Science/Research",
+        "License :: OSI Approved :: Apache Software License",
+        "Operating System :: OS Independent",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Programming Language :: Python :: 3.13",
+        "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    ],
+)
+
+# Release checklist
+# 1. Change the version in __init__.py and setup.py to the release version, e.g. from "0.6.1.dev0" to "0.7.0"
+# 2. Check if there are any deprecations that need to be addressed for this release by searching for "# TODO" in the code
+# 3. Commit these changes with the message: "Release: VERSION", create a PR and merge it.
+# 4. Add a tag in git to mark the release: "git tag -a v<VERSION> -m 'Adds tag <VERSION> for pypi' "
+#    Push the tag to git:
+#      git push --tags origin main
+#    It is necessary to work on the original repository, not on a fork.
+# 5. Run the following commands in the top-level directory:
+#      python setup.py bdist_wheel
+#      python setup.py sdist
+#    Ensure that you are on the clean and up-to-date main branch (git status --untracked-files=no should not list any
+#    files and show the main branch)
+# 6. Upload the package to the pypi test server first:
+#      twine upload dist/* -r pypitest
+# 7. Check that you can install it in a virtualenv by running:
+#      pip install -i https://testpypi.python.org/pypi --extra-index-url https://pypi.org/simple peft
+# 8. Upload the final version to actual pypi:
+#      twine upload dist/* -r pypi
+# 9. Add release notes to the tag on https://github.com/huggingface/peft/releases once everything is looking hunky-dory.
+#      Check the notes here: https://docs.google.com/document/d/1k-sOIfykuKjWcOIALqjhFKz4amFEp-myeJUJEzNgjoU/edit?usp=sharing
+# 10. Update the version in __init__.py, setup.py to the bumped patch version + ".dev0" (e.g. from "0.7.0" to "0.7.1.dev0")

tasks/tasksmith-c488fc138ba1/environment/source/src/peft/__init__.py

@@ -0,0 +1,310 @@
+# Copyright 2023-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+__version__ = "0.19.2.dev0"
+
+from .auto import (
+    MODEL_TYPE_TO_PEFT_MODEL_MAPPING,
+    AutoPeftModel,
+    AutoPeftModelForCausalLM,
+    AutoPeftModelForFeatureExtraction,
+    AutoPeftModelForQuestionAnswering,
+    AutoPeftModelForSeq2SeqLM,
+    AutoPeftModelForSequenceClassification,
+    AutoPeftModelForTokenClassification,
+)
+from .config import PeftConfig, PromptLearningConfig
+from .helpers import find_kappa_target_modules
+from .mapping import (
+    PEFT_TYPE_TO_CONFIG_MAPPING,
+    PEFT_TYPE_TO_MIXED_MODEL_MAPPING,
+    PEFT_TYPE_TO_TUNER_MAPPING,
+    get_peft_config,
+    inject_adapter_in_model,
+)
+from .mapping_func import get_peft_model
+from .mixed_model import PeftMixedModel
+from .peft_model import (
+    PeftModel,
+    PeftModelForCausalLM,
+    PeftModelForFeatureExtraction,
+    PeftModelForQuestionAnswering,
+    PeftModelForSeq2SeqLM,
+    PeftModelForSequenceClassification,
+    PeftModelForTokenClassification,
+    get_layer_status,
+    get_model_status,
+)
+from .tuners import (
+    AdaLoraConfig,
+    AdaLoraModel,
+    AdamssConfig,
+    AdamssModel,
+    AdaptionPromptConfig,
+    AdaptionPromptModel,
+    ArrowConfig,
+    BdLoraConfig,
+    BeftConfig,
+    BeftModel,
+    BOFTConfig,
+    BOFTModel,
+    C3AConfig,
+    C3AModel,
+    CartridgeConfig,
+    CartridgeEncoder,
+    CPTConfig,
+    CPTEmbedding,
+    DeloraConfig,
+    DeloraModel,
+    EvaConfig,
+    FourierFTConfig,
+    FourierFTModel,
+    FrodConfig,
+    FrodModel,
+    GraloraConfig,
+    GraloraModel,
+    HiraConfig,
+    HiraModel,
+    HRAConfig,
+    HRAModel,
+    IA3Config,
+    IA3Model,
+    LilyConfig,
+    LilyModel,
+    LNTuningConfig,
+    LNTuningModel,
+    LoftQConfig,
+    LoHaConfig,
+    LoHaModel,
+    LoKrConfig,
+    LoKrModel,
+    LoraConfig,
+    LoraGAConfig,
+    LoraModel,
+    LoraRuntimeConfig,
+    MissConfig,
+    MissModel,
+    MontecloraConfig,
+    MultitaskPromptTuningConfig,
+    MultitaskPromptTuningInit,
+    OFTConfig,
+    OFTModel,
+    OSFConfig,
+    OSFModel,
+    PeanutConfig,
+    PeanutModel,
+    PolyConfig,
+    PolyModel,
+    PrefixEncoder,
+    PrefixTuningConfig,
+    PromptEmbedding,
+    PromptEncoder,
+    PromptEncoderConfig,
+    PromptEncoderReparameterizationType,
+    PromptTuningConfig,
+    PromptTuningInit,
+    PsoftConfig,
+    PsoftModel,
+    PveraConfig,
+    PveraModel,
+    RandLoraConfig,
+    RandLoraModel,
+    RoadConfig,
+    RoadModel,
+    ShiraConfig,
+    ShiraModel,
+    TinyLoraConfig,
+    TinyLoraModel,
+    TrainableTokensConfig,
+    TrainableTokensModel,
+    VBLoRAConfig,
+    VBLoRAModel,
+    VeloraConfig,
+    VeraConfig,
+    VeraModel,
+    WaveFTConfig,
+    WaveFTModel,
+    XLoraConfig,
+    XLoraModel,
+    convert_to_lora,
+    create_arrow_model,
+    get_eva_state_dict,
+    initialize_lora_eva_weights,
+    preprocess_loraga,
+    save_as_lora,
+)
+from .tuners.cartridge.utils import (
+    compose_cartridge_adapters,
+    initialize_kv_prefix_from_past_key_values,
+    initialize_kv_prefix_from_text,
+    prompt_embeddings_from_past_key_values,
+)
+from .utils import (
+    TRANSFORMERS_MODELS_TO_PREFIX_TUNING_POSTPROCESS_MAPPING,
+    PeftType,
+    PeftWarning,
+    TaskType,
+    bloom_model_postprocess_past_key_value,
+    cast_mixed_precision_params,
+    get_peft_model_state_dict,
+    load_peft_weights,
+    prepare_model_for_kbit_training,
+    replace_lora_weights_loftq,
+    set_peft_model_state_dict,
+    shift_tokens_right,
+)
+
+
+__all__ = [
+    "MODEL_TYPE_TO_PEFT_MODEL_MAPPING",
+    "PEFT_TYPE_TO_CONFIG_MAPPING",
+    "PEFT_TYPE_TO_MIXED_MODEL_MAPPING",
+    "PEFT_TYPE_TO_TUNER_MAPPING",
+    "TRANSFORMERS_MODELS_TO_PREFIX_TUNING_POSTPROCESS_MAPPING",
+    "AdaLoraConfig",
+    "AdaLoraModel",
+    "AdamssConfig",
+    "AdamssModel",
+    "AdaptionPromptConfig",
+    "AdaptionPromptModel",
+    "ArrowConfig",
+    "AutoPeftModel",
+    "AutoPeftModelForCausalLM",
+    "AutoPeftModelForFeatureExtraction",
+    "AutoPeftModelForQuestionAnswering",
+    "AutoPeftModelForSeq2SeqLM",
+    "AutoPeftModelForSequenceClassification",
+    "AutoPeftModelForTokenClassification",
+    "BOFTConfig",
+    "BOFTModel",
+    "BdLoraConfig",
+    "BeftConfig",
+    "BeftModel",
+    "C3AConfig",
+    "C3AModel",
+    "CPTConfig",
+    "CPTEmbedding",
+    "CartridgeConfig",
+    "CartridgeEncoder",
+    "DeloraConfig",
+    "DeloraModel",
+    "EvaConfig",
+    "FourierFTConfig",
+    "FourierFTModel",
+    "FrodConfig",
+    "FrodModel",
+    "GraloraConfig",
+    "GraloraModel",
+    "HRAConfig",
+    "HRAModel",
+    "HiraConfig",
+    "HiraModel",
+    "IA3Config",
+    "IA3Model",
+    "LNTuningConfig",
+    "LNTuningModel",
+    "LilyConfig",
+    "LilyModel",
+    "LoHaConfig",
+    "LoHaModel",
+    "LoKrConfig",
+    "LoKrModel",
+    "LoftQConfig",
+    "LoraConfig",
+    "LoraGAConfig",
+    "LoraModel",
+    "LoraRuntimeConfig",
+    "MissConfig",
+    "MissModel",
+    "MontecloraConfig",
+    "MultitaskPromptTuningConfig",
+    "MultitaskPromptTuningInit",
+    "OFTConfig",
+    "OFTModel",
+    "OSFConfig",
+    "OSFModel",
+    "PeanutConfig",
+    "PeanutModel",
+    "PeftConfig",
+    "PeftMixedModel",
+    "PeftModel",
+    "PeftModelForCausalLM",
+    "PeftModelForFeatureExtraction",
+    "PeftModelForQuestionAnswering",
+    "PeftModelForSeq2SeqLM",
+    "PeftModelForSequenceClassification",
+    "PeftModelForTokenClassification",
+    "PeftType",
+    "PeftWarning",
+    "PolyConfig",
+    "PolyModel",
+    "PrefixEncoder",
+    "PrefixTuningConfig",
+    "PromptEmbedding",
+    "PromptEncoder",
+    "PromptEncoderConfig",
+    "PromptEncoderReparameterizationType",
+    "PromptLearningConfig",
+    "PromptTuningConfig",
+    "PromptTuningInit",
+    "PsoftConfig",
+    "PsoftModel",
+    "PveraConfig",
+    "PveraModel",
+    "RandLoraConfig",
+    "RandLoraModel",
+    "RoadConfig",
+    "RoadModel",
+    "ShiraConfig",
+    "ShiraModel",
+    "TaskType",
+    "TinyLoraConfig",
+    "TinyLoraModel",
+    "TrainableTokensConfig",
+    "TrainableTokensModel",
+    "VBLoRAConfig",
+    "VBLoRAConfig",
+    "VBLoRAModel",
+    "VeloraConfig",
+    "VeraConfig",
+    "VeraModel",
+    "WaveFTConfig",
+    "WaveFTModel",
+    "XLoraConfig",
+    "XLoraModel",
+    "bloom_model_postprocess_past_key_value",
+    "cast_mixed_precision_params",
+    "compose_cartridge_adapters",
+    "convert_to_lora",
+    "create_arrow_model",
+    "find_kappa_target_modules",
+    "get_eva_state_dict",
+    "get_layer_status",
+    "get_model_status",
+    "get_peft_config",
+    "get_peft_model",
+    "get_peft_model_state_dict",
+    "initialize_kv_prefix_from_past_key_values",
+    "initialize_kv_prefix_from_text",
+    "initialize_lora_eva_weights",
+    "inject_adapter_in_model",
+    "load_peft_weights",
+    "prepare_model_for_kbit_training",
+    "preprocess_loraga",
+    "prompt_embeddings_from_past_key_values",
+    "replace_lora_weights_loftq",
+    "save_as_lora",
+    "set_peft_model_state_dict",
+    "shift_tokens_right",
+]

tasks/tasksmith-c488fc138ba1/environment/source/src/peft/auto.py

@@ -0,0 +1,225 @@
+# Copyright 2023-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import importlib
+import os
+from typing import Optional
+
+from transformers import (
+    AutoModel,
+    AutoModelForCausalLM,
+    AutoModelForQuestionAnswering,
+    AutoModelForSeq2SeqLM,
+    AutoModelForSequenceClassification,
+    AutoModelForTokenClassification,
+    AutoTokenizer,
+)
+
+from .config import PeftConfig
+from .peft_model import (
+    PeftModel,
+    PeftModelForCausalLM,
+    PeftModelForFeatureExtraction,
+    PeftModelForQuestionAnswering,
+    PeftModelForSeq2SeqLM,
+    PeftModelForSequenceClassification,
+    PeftModelForTokenClassification,
+)
+from .utils.constants import TOKENIZER_CONFIG_NAME
+from .utils.other import check_file_exists_on_hf_hub
+
+
+MODEL_TYPE_TO_PEFT_MODEL_MAPPING: dict[str, type[PeftModel]] = {
+    "SEQ_CLS": PeftModelForSequenceClassification,
+    "SEQ_2_SEQ_LM": PeftModelForSeq2SeqLM,
+    "CAUSAL_LM": PeftModelForCausalLM,
+    "TOKEN_CLS": PeftModelForTokenClassification,
+    "QUESTION_ANS": PeftModelForQuestionAnswering,
+    "FEATURE_EXTRACTION": PeftModelForFeatureExtraction,
+}
+
+
+def get_default_import_allowlist():
+    return [
+        "diffusers",
+        "lerobot",
+        "megatron-core",
+        "transformers",
+    ]
+
+
+def check_import_allowlist(allowlist, parent_name):
+    """Ensure that the parent_name is in the allowlist or, at least, the prefix (e.g., "transformers.").
+    This is done because PEFT uses importlib.import_module on adapter config values. To prevent PEFT being used as a
+    means to execute code by importing a potentially malicious package (i.e. as a means to execute planted code), we
+    limit the possible packages to a known value.
+    """
+    if parent_name in allowlist:
+        return True
+
+    return any(parent_name.startswith(f"{allowed}.") for allowed in allowlist)
+
+
+class _BaseAutoPeftModel:
+    _target_class = None
+    _target_peft_class = None
+
+    def __init__(self, *args, **kwargs):
+        # For consistency with transformers: https://github.com/huggingface/transformers/blob/91d7df58b6537d385e90578dac40204cb550f706/src/transformers/models/auto/auto_factory.py#L400
+        raise EnvironmentError(  # noqa: UP024
+            f"{self.__class__.__name__} is designed to be instantiated "
+            f"using the `{self.__class__.__name__}.from_pretrained(pretrained_model_name_or_path)` or "
+            f"`{self.__class__.__name__}.from_config(config)` methods."
+        )
+
+    @classmethod
+    def from_pretrained(
+        cls,
+        pretrained_model_name_or_path,
+        adapter_name: str = "default",
+        is_trainable: bool = False,
+        config: Optional[PeftConfig] = None,
+        revision: Optional[str] = None,
+        import_allowlist: Optional[list[str]] = None,
+        **kwargs,
+    ):
+        r"""
+        A wrapper around all the preprocessing steps a user needs to perform in order to load a PEFT model. The kwargs
+        are passed along to `PeftConfig` that automatically takes care of filtering the kwargs of the Hub methods and
+        the config object init.
+
+        The parameters are equivalent to the ones of [`PeftModel.from_pretrained`]. Differences are documented below.
+
+        Args:
+            import_allowlist (`list[str]`, *optional*, defaults to `{get_default_import_allowlist()}`)
+                AutoPeftModel will attempt to instantiate the base model that is configured in the adapter config.
+                Since this operation needs to potentially import other packages, this allowlist is a safe-guard to
+                prevent importing malicious packages. You may need to specify your package's import name here if it is
+                not in the defaults.
+        """
+        peft_config = PeftConfig.from_pretrained(pretrained_model_name_or_path, revision=revision, **kwargs)
+        base_model_path = peft_config.base_model_name_or_path
+        base_model_revision = peft_config.revision
+
+        if import_allowlist is None:
+            import_allowlist = get_default_import_allowlist()
+
+        task_type = getattr(peft_config, "task_type", None)
+
+        if cls._target_class is not None:
+            target_class = cls._target_class
+        elif cls._target_class is None and task_type is not None:
+            # this is only in the case where we use `AutoPeftModel`
+            raise ValueError(
+                "Cannot use `AutoPeftModel` with a task type, please use a specific class for your task type. (e.g. `AutoPeftModelForCausalLM` for `task_type='CAUSAL_LM'`)"
+            )
+
+        if task_type is not None:
+            expected_target_class = MODEL_TYPE_TO_PEFT_MODEL_MAPPING[task_type]
+            if cls._target_peft_class.__name__ != expected_target_class.__name__:
+                raise ValueError(
+                    f"Expected target PEFT class: {expected_target_class.__name__}, but you have asked for: {cls._target_peft_class.__name__}"
+                    " make sure that you are loading the correct model for your task type."
+                )
+        elif task_type is None and getattr(peft_config, "auto_mapping", None) is not None:
+            auto_mapping = getattr(peft_config, "auto_mapping", None)
+            base_model_class = auto_mapping["base_model_class"]
+            parent_library_name = auto_mapping["parent_library"]
+
+            if not check_import_allowlist(import_allowlist, parent_library_name):
+                raise ValueError(
+                    f"The auto mapping wants to import '{parent_library_name}' which is not in the import allowlist. "
+                    "If you are sure that importing this library is safe, specify "
+                    f"`import_allowlist=['{parent_library_name}']` in `from_pretrained()`."
+                )
+
+            parent_library = importlib.import_module(parent_library_name)
+            target_class = getattr(parent_library, base_model_class)
+        else:
+            raise ValueError(
+                "Cannot infer the auto class from the config, please make sure that you are loading the correct model for your task type."
+            )
+
+        base_model = target_class.from_pretrained(base_model_path, revision=base_model_revision, **kwargs)
+
+        tokenizer_exists = False
+        if os.path.exists(os.path.join(pretrained_model_name_or_path, TOKENIZER_CONFIG_NAME)):
+            tokenizer_exists = True
+        else:
+            token = kwargs.get("token", None)
+            if token is None:
+                token = kwargs.get("use_auth_token", None)
+
+            tokenizer_exists = check_file_exists_on_hf_hub(
+                repo_id=pretrained_model_name_or_path,
+                filename=TOKENIZER_CONFIG_NAME,
+                revision=revision,
+                repo_type=kwargs.get("repo_type", None),
+                token=token,
+            )
+
+        if tokenizer_exists and hasattr(base_model, "get_input_embeddings"):
+            tokenizer = AutoTokenizer.from_pretrained(
+                pretrained_model_name_or_path, trust_remote_code=kwargs.get("trust_remote_code", False)
+            )
+            embedding_size = base_model.get_input_embeddings().weight.shape[0]
+            if len(tokenizer) > embedding_size:
+                # only resize if the tokenizer has a larger vocab size than there are embeddings
+                base_model.resize_token_embeddings(len(tokenizer))
+
+        return cls._target_peft_class.from_pretrained(
+            base_model,
+            pretrained_model_name_or_path,
+            adapter_name=adapter_name,
+            is_trainable=is_trainable,
+            config=config,
+            **kwargs,
+        )
+
+
+class AutoPeftModel(_BaseAutoPeftModel):
+    _target_class = None
+    _target_peft_class = PeftModel
+
+
+class AutoPeftModelForCausalLM(_BaseAutoPeftModel):
+    _target_class = AutoModelForCausalLM
+    _target_peft_class = PeftModelForCausalLM
+
+
+class AutoPeftModelForSeq2SeqLM(_BaseAutoPeftModel):
+    _target_class = AutoModelForSeq2SeqLM
+    _target_peft_class = PeftModelForSeq2SeqLM
+
+
+class AutoPeftModelForSequenceClassification(_BaseAutoPeftModel):
+    _target_class = AutoModelForSequenceClassification
+    _target_peft_class = PeftModelForSequenceClassification
+
+
+class AutoPeftModelForTokenClassification(_BaseAutoPeftModel):
+    _target_class = AutoModelForTokenClassification
+    _target_peft_class = PeftModelForTokenClassification
+
+
+class AutoPeftModelForQuestionAnswering(_BaseAutoPeftModel):
+    _target_class = AutoModelForQuestionAnswering
+    _target_peft_class = PeftModelForQuestionAnswering
+
+
+class AutoPeftModelForFeatureExtraction(_BaseAutoPeftModel):
+    _target_class = AutoModel
+    _target_peft_class = PeftModelForFeatureExtraction

tasks/tasksmith-c488fc138ba1/environment/source/src/peft/config.py

@@ -0,0 +1,408 @@
+# Copyright 2023-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from __future__ import annotations
+
+import importlib.metadata
+import inspect
+import json
+import os
+import warnings
+from dataclasses import asdict, dataclass, field
+from typing import Optional, Union
+
+import packaging.version
+from huggingface_hub import hf_hub_download
+from transformers.utils import PushToHubMixin, http_user_agent
+
+from peft import __version__
+
+from .utils import CONFIG_NAME, PeftType, TaskType
+
+
+# we expect at least these keys to be present in a PEFT adapter_config.json
+MIN_EXPECTED_CONFIG_KEYS = {"peft_type"}
+
+
+def _check_and_remove_unused_kwargs(cls, kwargs):
+    """Make PEFT configs forward-compatible by removing unused kwargs that were added in later PEFT versions.
+
+    This assumes that removing the unused kwargs will not affect the default behavior.
+
+    Returns the filtered kwargs and the set of removed keys.
+    """
+    # it's not pretty but eh
+    signature_parameters = inspect.signature(cls.__init__).parameters
+    unexpected_kwargs = set(kwargs.keys()) - set(signature_parameters.keys())
+    for key in unexpected_kwargs:
+        del kwargs[key]
+    return kwargs, unexpected_kwargs
+
+
+def _is_dev_version(version: str) -> bool:
+    # check if the given version is a dev version
+    return packaging.version.Version(version).dev is not None
+
+
+def _get_commit_hash(pkg_name: str) -> str | None:
+    # If PEFT was installed from a specific commit hash, try to get it. This works e.g. when installing PEFT with `pip
+    # install git+https://github.com/huggingface/peft.git@<HASH>`. This works not for other means, like editable
+    # installs.
+    try:
+        dist = importlib.metadata.distribution(pkg_name)
+    except importlib.metadata.PackageNotFoundError:
+        return None
+
+    # See: https://packaging.python.org/en/latest/specifications/direct-url/
+    for path in dist.files or []:
+        if path.name == "direct_url.json":
+            direct_url = json.loads((dist.locate_file(path)).read_text())
+            vcs_info = direct_url.get("vcs_info")
+            if vcs_info and "commit_id" in vcs_info:
+                return vcs_info["commit_id"]
+    return None
+
+
+@dataclass
+class PeftConfigMixin(PushToHubMixin):
+    r"""
+    This is the base configuration class for PEFT adapter models. It contains all the methods that are common to all
+    PEFT adapter models. This class inherits from [`~transformers.utils.PushToHubMixin`] which contains the methods to
+    push your model to the Hub. The method `save_pretrained` will save the configuration of your adapter model in a
+    directory. The method `from_pretrained` will load the configuration of your adapter model from a directory.
+
+    Args:
+        peft_type (Union[[`~peft.utils.config.PeftType`], `str`]): The type of Peft method to use.
+    """
+
+    task_type: Optional[TaskType] = field(default=None, metadata={"help": "The type of task."})
+    peft_type: Optional[PeftType] = field(default=None, metadata={"help": "The type of PEFT model."})
+    auto_mapping: Optional[dict] = field(
+        default=None, metadata={"help": "An auto mapping dict to help retrieve the base model class if needed."}
+    )
+    peft_version: Optional[str] = field(default=None, metadata={"help": "PEFT version, leave empty to auto-fill."})
+
+    def __post_init__(self):
+        # check for invalid task type
+        if (self.task_type is not None) and (self.task_type not in list(TaskType)):
+            raise ValueError(
+                f"Invalid task type: '{self.task_type}'. Must be one of the following task types: {', '.join(TaskType)}."
+            )
+        if self.peft_version is None:
+            self.peft_version = self._get_peft_version()
+
+    @staticmethod
+    def _get_peft_version() -> str:
+        # gets the current peft version; if it's a dev version, try to get the commit hash too, as the dev version is
+        # ambiguous
+        version = __version__
+        if not _is_dev_version(version):
+            return version
+
+        try:
+            git_hash = _get_commit_hash("peft")
+            if git_hash is None:
+                git_hash = "UNKNOWN"
+        except Exception:
+            # Broad exception: We never want to break user code just because the git_hash could not be determined
+            warnings.warn(
+                "A dev version of PEFT is used but there was an error while trying to determine the commit hash. "
+                "Please open an issue: https://github.com/huggingface/peft/issues"
+            )
+            git_hash = "UNKNOWN"
+        version = version + f"@{git_hash}"
+        return version
+
+    def to_dict(self) -> dict:
+        r"""
+        Returns the configuration for your adapter model as a dictionary.
+        """
+        return asdict(self)
+
+    def save_pretrained(self, save_directory: str, **kwargs) -> None:
+        r"""
+        This method saves the configuration of your adapter model in a directory.
+
+        Args:
+            save_directory (`str`):
+                The directory where the configuration will be saved.
+            kwargs (additional keyword arguments, *optional*):
+                Additional keyword arguments passed along to the [`~transformers.utils.PushToHubMixin.push_to_hub`]
+                method.
+        """
+        if os.path.isfile(save_directory):
+            raise AssertionError(f"Provided path ({save_directory}) should be a directory, not a file")
+
+        os.makedirs(save_directory, exist_ok=True)
+        auto_mapping_dict = kwargs.pop("auto_mapping_dict", None)
+
+        output_dict = self.to_dict()
+        # converting set type to list
+        for key, value in output_dict.items():
+            if isinstance(value, set):
+                output_dict[key] = list(value)
+
+        output_path = os.path.join(save_directory, CONFIG_NAME)
+
+        # Add auto mapping details for custom models.
+        if auto_mapping_dict is not None:
+            output_dict["auto_mapping"] = auto_mapping_dict
+
+        # save it
+        with open(output_path, "w") as writer:
+            writer.write(json.dumps(output_dict, indent=2, sort_keys=True))
+
+    @classmethod
+    def from_peft_type(cls, **kwargs):
+        r"""
+        This method loads the configuration of your adapter model from a set of kwargs.
+
+        The appropriate configuration type is determined by the `peft_type` argument. If `peft_type` is not provided,
+        the calling class type is instantiated.
+
+        Args:
+            kwargs (configuration keyword arguments):
+                Keyword arguments passed along to the configuration initialization.
+        """
+        # Avoid circular dependency .. TODO: fix this with a larger refactor
+        from peft.mapping import PEFT_TYPE_TO_CONFIG_MAPPING
+
+        # TODO: this hack is needed to fix the following issue (on commit 702f937):
+        # if someone saves a default config and loads it back with `PeftConfig` class it yields to
+        # not loading the correct config class.
+        #
+        # from peft import AdaLoraConfig, PeftConfig
+        # peft_config = AdaLoraConfig()
+        # print(peft_config)
+        # >>> AdaLoraConfig(peft_type=<PeftType.ADALORA: 'ADALORA'>, auto_mapping=None, base_model_name_or_path=None,
+        # revision=None, task_type=None, inference_mode=False, r=8, target_modules=None, lora_alpha=8, lora_dropout=0.0, ...
+        #
+        # peft_config.save_pretrained("./test_config")
+        # peft_config = PeftConfig.from_pretrained("./test_config")
+        # print(peft_config)
+        # >>> PeftConfig(peft_type='ADALORA', auto_mapping=None, base_model_name_or_path=None, revision=None, task_type=None, inference_mode=False)
+
+        if "peft_type" in kwargs:
+            peft_type = kwargs["peft_type"]
+            config_cls = PEFT_TYPE_TO_CONFIG_MAPPING[peft_type]
+        else:
+            config_cls = cls
+
+        try:
+            config = config_cls(**kwargs)
+        except TypeError as exc:
+            # Here we potentially handle forward compatibility. Sometimes new keywords are added to configs, which makes
+            # new configs incompatible with older PEFT versions. We catch these and remove them to allow the program to
+            # continue, but warn the user about it.
+
+            # First check if the error is due to unexpected keyword arguments, we don't want to accidentally catch
+            # other TypeErrors.
+            if "got an unexpected keyword argument" not in str(exc):
+                raise
+
+            filtered_kwargs, unexpected_kwargs = _check_and_remove_unused_kwargs(config_cls, kwargs)
+            if not MIN_EXPECTED_CONFIG_KEYS.issubset(set(filtered_kwargs.keys())):
+                raise TypeError(
+                    f"The {cls.__name__} config that is trying to be loaded is missing required keys: "
+                    f"{MIN_EXPECTED_CONFIG_KEYS}."
+                )
+
+            warnings.warn(
+                f"Unexpected keyword arguments {sorted(unexpected_kwargs)} for class {config_cls.__name__}, these are "
+                "ignored. This probably means that you're loading a configuration file that was saved using a "
+                "higher version of the library and additional parameters have been introduced since. It is "
+                "highly recommended to upgrade the PEFT version before continuing (e.g. by running `pip install "
+                "-U peft`)."
+            )
+            config = config_cls.from_peft_type(**filtered_kwargs)
+        return config
+
+    @classmethod
+    def from_pretrained(cls, pretrained_model_name_or_path: str, subfolder: Optional[str] = None, **kwargs):
+        r"""
+        This method loads the configuration of your adapter model from a directory.
+
+        Args:
+            pretrained_model_name_or_path (`str`):
+                The directory or the Hub repository id where the configuration is saved.
+            kwargs (additional keyword arguments, *optional*):
+                Additional keyword arguments passed along to the child class initialization.
+        """
+        path = (
+            os.path.join(pretrained_model_name_or_path, subfolder)
+            if subfolder is not None
+            else pretrained_model_name_or_path
+        )
+
+        hf_hub_download_kwargs, class_kwargs, _ = cls._split_kwargs(kwargs)
+        if "user_agent" not in hf_hub_download_kwargs:
+            hf_hub_download_kwargs["user_agent"] = http_user_agent()
+
+        if os.path.isfile(os.path.join(path, CONFIG_NAME)):
+            config_file = os.path.join(path, CONFIG_NAME)
+        else:
+            try:
+                config_file = hf_hub_download(
+                    pretrained_model_name_or_path, CONFIG_NAME, subfolder=subfolder, **hf_hub_download_kwargs
+                )
+            except Exception as exc:
+                raise ValueError(f"Can't find '{CONFIG_NAME}' at '{pretrained_model_name_or_path}'") from exc
+
+        loaded_attributes = cls.from_json_file(config_file)
+        kwargs = {**class_kwargs, **loaded_attributes}
+        kwargs = cls.check_kwargs(**kwargs)
+        return cls.from_peft_type(**kwargs)
+
+    @classmethod
+    def from_json_file(cls, path_json_file: str, **kwargs):
+        r"""
+        Loads a configuration file from a json file.
+
+        Args:
+            path_json_file (`str`):
+                The path to the json file.
+        """
+        with open(path_json_file) as file:
+            json_object = json.load(file)
+
+        # Sanity check that config does not contain a runtime_config
+        if "runtime_config" in json_object:
+            warnings.warn(
+                "The configuration file contains a `runtime_config` key. This is ignored. Runtime configurations are only valid at runtime."
+            )
+            del json_object["runtime_config"]
+
+        return json_object
+
+    @classmethod
+    def _split_kwargs(cls, kwargs):
+        hf_hub_download_kwargs = {}
+        class_kwargs = {}
+        other_kwargs = {}
+
+        for key, value in kwargs.items():
+            if key in inspect.signature(hf_hub_download).parameters:
+                hf_hub_download_kwargs[key] = value
+            elif key in list(cls.__annotations__):
+                class_kwargs[key] = value
+            else:
+                other_kwargs[key] = value
+
+        return hf_hub_download_kwargs, class_kwargs, other_kwargs
+
+    @classmethod
+    def _get_peft_type(
+        cls,
+        model_id: str,
+        **hf_hub_download_kwargs,
+    ):
+        subfolder = hf_hub_download_kwargs.get("subfolder", None)
+
+        path = os.path.join(model_id, subfolder) if subfolder is not None else model_id
+
+        if os.path.isfile(os.path.join(path, CONFIG_NAME)):
+            config_file = os.path.join(path, CONFIG_NAME)
+        else:
+            try:
+                config_file = hf_hub_download(
+                    model_id,
+                    CONFIG_NAME,
+                    **hf_hub_download_kwargs,
+                )
+            except Exception:
+                raise ValueError(f"Can't find '{CONFIG_NAME}' at '{model_id}'")
+
+        loaded_attributes = cls.from_json_file(config_file)
+        return loaded_attributes["peft_type"]
+
+    @classmethod
+    def check_kwargs(cls, **kwargs):
+        """Check kwargs before initializing the config instance.
+
+        Subclasses can override this method to add specific checks.
+
+        """
+        return kwargs
+
+    @property
+    def is_prompt_learning(self) -> bool:
+        r"""
+        Utility method to check if the configuration is for prompt learning.
+        """
+        return False
+
+    @property
+    def is_adaption_prompt(self) -> bool:
+        """Return True if this is an adaption prompt config."""
+        return False
+
+
+@dataclass
+class PeftConfig(PeftConfigMixin):
+    """
+    This is the base configuration class to store the configuration of a [`PeftModel`].
+
+    Args:
+        peft_type (Union[[`~peft.utils.config.PeftType`], `str`]): The type of Peft method to use.
+        task_type (Union[[`~peft.utils.config.TaskType`], `str`]): The type of task to perform.
+        inference_mode (`bool`, defaults to `False`): Whether to use the Peft model in inference mode.
+    """
+
+    base_model_name_or_path: Optional[str] = field(
+        default=None, metadata={"help": "The name of the base model to use."}
+    )
+    revision: Optional[str] = field(default=None, metadata={"help": "The specific base model version to use."})
+    peft_type: Optional[Union[str, PeftType]] = field(default=None, metadata={"help": "Peft type"})
+    task_type: Optional[Union[str, TaskType]] = field(default=None, metadata={"help": "Task type"})
+    inference_mode: bool = field(default=False, metadata={"help": "Whether to use inference mode"})
+
+
+@dataclass
+class PromptLearningConfig(PeftConfig):
+    """
+    This is the base configuration class to store the configuration of [`PrefixTuning`], [`PromptEncoder`], or
+    [`PromptTuning`].
+
+    Args:
+        num_virtual_tokens (`int`): The number of virtual tokens to use.
+        token_dim (`int`): The hidden embedding dimension of the base transformer model.
+        num_transformer_submodules (`int`): The number of transformer submodules in the base transformer model.
+        num_attention_heads (`int`): The number of attention heads in the base transformer model.
+        num_layers (`int`): The number of layers in the base transformer model.
+    """
+
+    num_virtual_tokens: int = field(default=None, metadata={"help": "Number of virtual tokens"})
+    token_dim: int = field(
+        default=None, metadata={"help": "The hidden embedding dimension of the base transformer model"}
+    )
+    num_transformer_submodules: Optional[int] = field(
+        default=None, metadata={"help": "Number of transformer submodules"}
+    )
+    num_attention_heads: Optional[int] = field(default=None, metadata={"help": "Number of attention heads"})
+    num_layers: Optional[int] = field(default=None, metadata={"help": "Number of transformer layers"})
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": "List of extra modules to be set as trainable and saved in the final checkpoint. "
+            "For example, in Sequence Classification or Token Classification tasks, "
+            "the final layer `classifier/score` are randomly initialized and as such need to be trainable and saved. "
+            "The module(s) will be fully fine-tuned."
+        },
+    )
+
+    @property
+    def is_prompt_learning(self) -> bool:
+        r"""
+        Utility method to check if the configuration is for prompt learning.
+        """
+        return True

tasks/tasksmith-c488fc138ba1/environment/source/src/peft/functional.py

@@ -0,0 +1,34 @@
+# Copyright 2025-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Functions that are useful for integration with non-PeftModel models, e.g. transformers or diffusers.
+
+The functions provided here can be considered "public API" of PEFT and hence are safe to be used by packages that
+provide PEFT integrations.
+"""
+
+from peft.mapping import inject_adapter_in_model
+from peft.tuners.tuners_utils import cast_adapter_dtype, delete_adapter, set_adapter, set_requires_grad
+from peft.utils import get_peft_model_state_dict, set_peft_model_state_dict
+
+
+__all__ = [
+    "cast_adapter_dtype",
+    "delete_adapter",
+    "get_peft_model_state_dict",
+    "inject_adapter_in_model",
+    "set_adapter",
+    "set_peft_model_state_dict",
+    "set_requires_grad",
+]

tasks/tasksmith-c488fc138ba1/environment/source/src/peft/helpers.py

@@ -0,0 +1,577 @@
+# Copyright 2023-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import inspect
+from contextlib import contextmanager
+from copy import deepcopy
+from functools import update_wrapper
+from types import MethodType
+from typing import Optional
+
+import torch
+from torch import nn
+
+
+try:
+    import bitsandbytes as bnb
+except ImportError:
+    bnb = None
+
+from tqdm.auto import tqdm
+
+from .peft_model import PeftConfig, PeftModel
+from .tuners.lora import LoraLayer, LoraModel, dora
+from .tuners.tuners_utils import BaseTunerLayer
+
+
+def update_forward_signature(model: PeftModel) -> None:
+    """
+    Updates the forward signature of the PeftModel to include parents class signature
+        model (`PeftModel`): Peft model to update the forward signature
+
+    Example:
+
+    ```python
+    >>> from transformers import WhisperForConditionalGeneration
+    >>> from peft import get_peft_model, LoraConfig
+    >>> from peft.helpers import update_forward_signature
+
+    >>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en")
+    >>> peft_config = LoraConfig(r=8, lora_alpha=32, lora_dropout=0.1, target_modules=["q_proj", "v_proj"])
+
+    >>> peft_model = get_peft_model(model, peft_config)
+    >>> update_forward_signature(peft_model)
+    ```
+    """
+
+    # Only update signature when the current forward signature only has *args and **kwargs
+    current_signature = inspect.signature(model.forward)
+    if (
+        len(current_signature.parameters) == 2
+        and "args" in current_signature.parameters
+        and "kwargs" in current_signature.parameters
+    ):
+        forward = deepcopy(model.forward.__func__)
+        update_wrapper(
+            forward, type(model.get_base_model()).forward, assigned=("__doc__", "__name__", "__annotations__")
+        )
+        model.forward = MethodType(forward, model)
+
+
+def update_generate_signature(model: PeftModel) -> None:
+    """
+    Updates the generate signature of a PeftModel with overriding generate to include parents class signature
+        model (`PeftModel`): Peft model to update the generate signature
+
+    Example:
+
+    ```python
+    >>> from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
+    >>> from peft import get_peft_model, LoraConfig, TaskType
+    >>> from peft.helpers import update_generate_signature
+
+    >>> model_name_or_path = "bigscience/mt0-large"
+    >>> tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)
+    >>> model = AutoModelForSeq2SeqLM.from_pretrained(model_name_or_path)
+
+    >>> peft_config = LoraConfig(
+    ...     task_type=TaskType.SEQ_2_SEQ_LM, inference_mode=False, r=8, lora_alpha=32, lora_dropout=0.1
+    ... )
+    >>> peft_model = get_peft_model(model, peft_config)
+    >>> update_generate_signature(peft_model)
+    >>> help(peft_model.generate)
+    ```
+    """
+    if not hasattr(model, "generate"):
+        return
+    current_signature = inspect.signature(model.generate)
+    if (
+        len(current_signature.parameters) == 2
+        and "args" in current_signature.parameters
+        and "kwargs" in current_signature.parameters
+    ) or (len(current_signature.parameters) == 1 and "kwargs" in current_signature.parameters):
+        generate = deepcopy(model.generate.__func__)
+        update_wrapper(
+            generate,
+            type(model.get_base_model()).generate,
+            assigned=("__doc__", "__name__", "__annotations__"),
+        )
+        model.generate = MethodType(generate, model)
+
+
+def update_signature(model: PeftModel, method: str = "all") -> None:
+    """
+    Updates the signature of a PeftModel include parents class signature for forward or generate method
+        model (`PeftModel`): Peft model to update generate or forward signature method (`str`): method to update
+        signature choose one of "forward", "generate", "all"
+
+    Example:
+    ```python
+    >>> from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
+    >>> from peft import get_peft_model, LoraConfig, TaskType
+    >>> from peft.helpers import update_signature
+
+    >>> model_name_or_path = "bigscience/mt0-large"
+    >>> tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)
+    >>> model = AutoModelForSeq2SeqLM.from_pretrained(model_name_or_path)
+
+    >>> peft_config = LoraConfig(
+    ...     task_type=TaskType.SEQ_2_SEQ_LM, inference_mode=False, r=8, lora_alpha=32, lora_dropout=0.1
+    ... )
+    >>> peft_model = get_peft_model(model, peft_config)
+    >>> update_signature(peft_model)
+    >>> help(peft_model.generate)
+    ```
+    """
+    if method == "forward":
+        update_forward_signature(model)
+    elif method == "generate":
+        update_generate_signature(model)
+    elif method == "all":
+        update_forward_signature(model)
+        update_generate_signature(model)
+    else:
+        raise ValueError(f"method {method} is not supported please choose one of ['forward', 'generate', 'all']")
+
+
+def check_if_peft_model(model_name_or_path: str) -> bool:
+    """
+    Check if the model is a PEFT model.
+
+    Args:
+        model_name_or_path (`str`):
+            Model id to check, can be local or on the Hugging Face Hub.
+
+    Returns:
+        `bool`: True if the model is a PEFT model, False otherwise.
+    """
+    is_peft_model = True
+    try:
+        PeftConfig.from_pretrained(model_name_or_path)
+    except Exception:
+        # allow broad exceptions so that this works even if new exceptions are added on HF Hub side
+        is_peft_model = False
+
+    return is_peft_model
+
+
+@contextmanager
+def rescale_adapter_scale(model, multiplier):
+    """
+    Context manager to temporarily rescale the scaling of the LoRA adapter in a model.
+
+    The original scaling values are restored when the context manager exits. This context manager works with the
+    transformers and diffusers models that have directly loaded LoRA adapters.
+
+    For LoRA, applying this context manager with multiplier in [0, 1] is strictly equivalent to applying
+    [wise-ft](https://huggingface.co/papers/2109.01903) (see [#1940](https://github.com/huggingface/peft/issues/1940)
+    for details). It can improve the performances of the model if there is a distribution shiftbetween the training
+    data used for fine-tuning, and the test data used during inference.
+
+    Warning: It has been reported that when using Apple's MPS backend for PyTorch, it is necessary to add a short sleep
+        time after exiting the context before the scales are fully restored.
+
+    Args:
+        model: The model containing `LoraLayer` modules whose scaling is to be adjusted.
+        multiplier (float or int):
+            The multiplier that rescales the `scaling` attribute. Must be of type float or int.
+
+    Raises:
+        ValueError: If the model does not contain any `LoraLayer`
+            instances, indicating that the model does not support scaling.
+
+    Example:
+
+    ```python
+    >>> model = ModelWithLoraLayer()
+    >>> multiplier = 0.5
+    >>> with rescale_adapter_scale(model, multiplier):
+    ...     outputs = model(**inputs)  # Perform operations with the scaled model
+    >>> outputs = model(**inputs)  # The original scaling values are restored here
+    ```
+    """
+    # check if multiplier has a valid data type
+    if not isinstance(multiplier, (float, int)):
+        raise TypeError(f"Argument multiplier should be of type float, got {type(multiplier)}")
+
+    # iterate on the model's modules and grab the original scaling attribute
+    # from the lora layers if present
+    original_scaling = {}
+    for module in model.modules():
+        if isinstance(module, LoraLayer):
+            original_scaling[module] = module.scaling.copy()
+            module.scaling = {k: v * multiplier for k, v in module.scaling.items()}
+
+    # check whether scaling is prohibited on model
+    # the original scaling dictionary should be empty
+    # if there were no lora layers
+    if not original_scaling:
+        raise ValueError("scaling is only supported for models with `LoraLayer`s")
+    try:
+        yield
+
+    finally:
+        # restore original scaling values after exiting the context
+        for module, scaling in original_scaling.items():
+            module.scaling = scaling
+
+
+@contextmanager
+def disable_input_dtype_casting(model: nn.Module, active: bool = True):
+    """
+    Context manager disables input dtype casting to the dtype of the weight.
+
+    Parameters:
+        model (nn.Module):
+            The model containing PEFT modules whose input dtype casting is to be adjusted.
+        active (bool):
+            Whether the context manager is active (default) or inactive.
+
+    """
+    # Additional info: Normally, the dtype of the weight and input need to match, which is why the dtype is cast.
+    # However, in certain circumustances, this is handled by forward hooks, e.g. when using layerwise casting in
+    # diffusers. In that case, PEFT casting the dtype interferes with the layerwise casting, which is why the option to
+    # disable it is given.
+    if not active:
+        yield
+        return
+
+    original_values = {}
+    for name, module in model.named_modules():
+        if not isinstance(module, BaseTunerLayer):
+            continue
+        original_values[name] = module.cast_input_dtype_enabled
+        module.cast_input_dtype_enabled = False
+
+    try:
+        yield
+    finally:
+        for name, module in model.named_modules():
+            if not isinstance(module, BaseTunerLayer):
+                continue
+            if name in original_values:
+                module.cast_input_dtype_enabled = original_values[name]
+
+
+class MontecloraTrainerMixin:
+    """
+    Mixin class for adding Monteclora variational loss to the Trainer's compute_loss method.
+
+    This mixin can be used with any Trainer class (e.g., Trainer, SFTTrainer) to add support for Monteclora's
+    variational regularization during training.
+
+    Example:
+        ```python
+        from transformers import Trainer
+        from peft import get_peft_model, LoraConfig
+        from peft.helpers import MontecloraTrainerMixin
+
+
+        # custom trainer that supports Monteclora
+        class MontecloraTrainer(MontecloraTrainerMixin, Trainer):
+            pass
+
+
+        # Configure LoRA with Monteclora
+        monteclora_config = MontecloraConfig(
+            num_samples=8,
+            sample_scaler=1e-4,
+            kl_loss_weight=1e-5,
+        )
+        lora_config = LoraConfig(
+            r=16,
+            lora_alpha=32,
+            target_modules=["q_proj", "v_proj"],
+            monteclora_config=monteclora_config,
+        )
+
+        # Get PEFT model and train
+        model = get_peft_model(base_model, lora_config)
+        trainer = MontecloraTrainer(model=model, args=training_args)
+        trainer.train()
+        ```
+    """
+
+    def compute_loss(self, model, inputs, return_outputs=False, **kwargs):
+        """
+        Compute loss with Monteclora variational regularization.
+
+        This method extends the standard compute_loss by adding the variational loss (KL divergence + entropy) from
+        Monteclora samplers to the task loss.
+
+        Args:
+            model: The model being trained
+            inputs: Input batch
+            return_outputs: Whether to return model outputs along with loss
+            **kwargs: Additional arguments
+
+        Returns:
+            loss or (loss, outputs) depending on return_outputs
+        """
+        if return_outputs:
+            task_loss, outputs = super().compute_loss(model, inputs, return_outputs=True, **kwargs)
+        else:
+            task_loss = super().compute_loss(model, inputs, return_outputs=False, **kwargs)
+            outputs = None
+
+        # `_get_monteclora_loss` already normalizes by the number of samplers within a single LoraModel.
+        # In the typical case there is exactly one LoraModel (PeftModel.base_model) so this loop runs once
+        # and matches the original behavior. For unusual setups with multiple tuners we additionally average
+        # across the LoraModels so the regularization magnitude does not scale with the number of tuners.
+        # `_get_monteclora_loss` returns 0.0 when no MonteCLoRA samplers are present, so this is a no-op
+        # for plain LoRA training.
+        monteclora_loss = 0.0
+        num_lora_models = 0
+        for module in model.modules():
+            if isinstance(module, LoraModel):
+                monteclora_loss = monteclora_loss + module._get_monteclora_loss()
+                num_lora_models += 1
+        if num_lora_models > 1:
+            monteclora_loss = monteclora_loss / num_lora_models
+
+        total_loss = task_loss + monteclora_loss
+
+        return (total_loss, outputs) if return_outputs else total_loss
+
+
+class DoraCaching:
+    """Context manager to enable DoRA caching, which improves speed of DoRA inference at the expense of memory.
+
+    With active caching, the materialized LoRA weight (B @ A) and the weight norm (base weight + LoRA weight) are
+    cached.
+
+    Even within the caching context, if the model is in training mode, caching is disabled. When the model switches to
+    training mode, the cache will be cleared.
+
+    Example:
+
+        ```py
+        >>> from peft.helpers import DoraCaching
+
+        >>> model.eval()  # put in eval model for caching to work
+
+        >>> with DoraCaching():  # use as a context manager
+        ...     output = model(inputs)
+
+        >>> dora_caching = DoraCaching()
+        >>> dora_caching(enabled=True)  # permanently enable caching
+        >>> output = model(inputs)
+        >>> dora_caching(enabled=False)  # permanently disable caching
+        >>> output = model(inputs)
+        ```
+
+    """
+
+    def __init__(self, enabled: bool = True) -> None:
+        self.enabled = enabled
+        self.prev_value = None
+
+    def __enter__(self):
+        self.prev_value = dora.ENABLE_DORA_CACHING
+        dora.ENABLE_DORA_CACHING = self.enabled
+
+    def __exit__(self, type, value, traceback):
+        dora.ENABLE_DORA_CACHING = self.prev_value
+        self.prev_value = None
+
+    def __call__(self, enabled: bool = True):
+        dora.ENABLE_DORA_CACHING = enabled
+
+
+class KappaTuneSelector:
+    """
+    Lightweight utility to compute per-module / per-parameter condition numbers and return the best LoRA targets.
+
+    Supports:
+    - Classic nn.Linear modules (target_modules in LoraConfig)
+    - Modern fused MoE weights stored as 3D nn.Parameter (gate_up_proj / down_proj, gate_proj / up_proj, etc.) used in
+      Llama-4, Qwen2_MoE, Qwen3_MoE, Mixtral, OLMoE and similar models. These are returned via target_parameters.
+
+    Notes:
+    - Condition-number computation requires running SVD and can take several minutes on very large models. A progress
+    bar can be shown/disabled via `show_progress`.
+
+    """
+
+    def __init__(
+        self,
+        model: nn.Module,
+        max_dim_size_to_analyze: int = 16384,
+        moe_param_suffixes: Optional[tuple[str, ...]] = None,
+        show_progress: bool = True,
+    ):
+        self.model = model
+        self.max_dim_size_to_analyze = max_dim_size_to_analyze
+        self.show_progress = show_progress
+        self.moe_param_suffixes = moe_param_suffixes or (
+            ".gate_up_proj",
+            ".down_proj",
+            ".gate_proj",
+            ".up_proj",
+        )
+        self._condition_numbers: Optional[dict[str, float]] = None
+        self._parameter_condition_numbers: Optional[dict[str, float]] = None
+
+    def _compute_kappas(self) -> None:
+        if self._condition_numbers is not None:
+            return
+
+        # === 1. nn.Linear modules ===
+        condition_numbers: dict[str, float] = {}
+        linear_modules = [
+            (module_name, module)
+            for module_name, module in self.model.named_modules()
+            if isinstance(module, nn.Linear)
+        ]
+        linear_iter = (
+            tqdm(linear_modules, desc="Computing SVD (linear layers)", unit="layer")
+            if self.show_progress
+            else linear_modules
+        )
+        for module_name, module in linear_iter:
+            weight = module.weight
+            if bnb is not None:
+                if hasattr(weight, "quant_state"):  # 4-bit
+                    w = bnb.functional.dequantize_4bit(weight.data, weight.quant_state).float()
+                elif hasattr(weight, "state") and hasattr(weight.state, "CB"):  # int8
+                    w = bnb.functional.int8_vectorwise_dequant(weight.state.CB, weight.state.SCB).float()
+                else:
+                    w = weight.data.detach().float()
+            else:
+                w = weight.data.detach().float()
+
+            if any(dim > self.max_dim_size_to_analyze for dim in w.shape):
+                continue
+
+            S = torch.linalg.svdvals(w.view(w.size(0), -1))
+            kappa = (S[0] / (S[-1] + 1e-8)).item()
+            condition_numbers[module_name] = kappa
+
+        self._condition_numbers = condition_numbers
+
+        # === 2. fused MoE parameters (3D nn.Parameter) ===
+        parameter_condition_numbers: dict[str, float] = {}
+        moe_params = [
+            (param_name, param)
+            for param_name, param in self.model.named_parameters()
+            if any(param_name.endswith(s) for s in self.moe_param_suffixes) and param.dim() == 3
+        ]
+        moe_iter = (
+            tqdm(moe_params, desc="Computing SVD (MoE parameters)", unit="param") if self.show_progress else moe_params
+        )
+        for param_name, param in moe_iter:
+            w = param.data.detach().float()
+            num_experts, *expert_shape = w.shape
+
+            if any(dim > self.max_dim_size_to_analyze for dim in expert_shape):
+                continue
+
+            kappas = []
+            for expert_idx in range(num_experts):
+                expert_w = w[expert_idx]
+                S = torch.linalg.svdvals(expert_w)
+                kappa = (S[0] / (S[-1] + 1e-8)).item()
+                kappas.append(kappa)
+            kappa = sum(kappas) / len(kappas)
+            parameter_condition_numbers[param_name] = kappa
+
+        self._parameter_condition_numbers = parameter_condition_numbers
+
+    def get_best_targets(
+        self, top_p: Optional[float] = None, num_modules: Optional[int] = None, threshold: Optional[float] = None
+    ) -> list[str]:
+        self._compute_kappas()
+        if not self._condition_numbers:
+            return []
+
+        sorted_modules = sorted(self._condition_numbers.items(), key=lambda x: x[1])
+
+        if num_modules is not None:
+            k = min(num_modules, len(sorted_modules))
+            return [name for name, _ in sorted_modules[:k]]
+
+        if top_p is not None:
+            k = max(1, int(len(sorted_modules) * top_p))
+            return [name for name, _ in sorted_modules[:k]]
+
+        if threshold is not None:
+            return [name for name, kappa in sorted_modules if kappa <= threshold]
+
+        return [name for name, _ in sorted_modules]
+
+    def get_best_target_parameters(
+        self, top_p: Optional[float] = None, num_modules: Optional[int] = None, threshold: Optional[float] = None
+    ) -> list[str]:
+        self._compute_kappas()
+        if not self._parameter_condition_numbers:
+            return []
+
+        sorted_params = sorted(self._parameter_condition_numbers.items(), key=lambda x: x[1])
+
+        if num_modules is not None:
+            k = min(num_modules, len(sorted_params))
+            return [name for name, _ in sorted_params[:k]]
+
+        if top_p is not None:
+            k = max(1, int(len(sorted_params) * top_p))
+            return [name for name, _ in sorted_params[:k]]
+
+        if threshold is not None:
+            return [name for name, kappa in sorted_params if kappa <= threshold]
+
+        return [name for name, _ in sorted_params]
+
+
+def find_kappa_target_modules(
+    model: nn.Module,
+    top_p: float = 0.2,
+    max_dim_size_to_analyze: int = 16384,
+    moe_param_suffixes: Optional[tuple[str, ...]] = None,
+    show_progress: bool = True,
+) -> dict[str, Optional[list[str]]]:
+    """
+    One-liner convenience function for KappaTune target selection. Returns both target_modules and target_parameters.
+
+    Args:
+        model (nn.Module):
+            Base model whose weights will be analyzed for condition numbers.
+        top_p (float, optional):
+            Select the top fraction of candidate modules/parameters with the lowest condition numbers.
+        max_dim_size_to_analyze (int, optional):
+            Upper bound on the maximum matrix dimension analyzed via SVD. Defaults to 16384.
+        moe_param_suffixes (Optional[tuple[str, ...]], optional):
+            Parameter-name suffixes used to identify fused MoE tensors that should be returned via `target_parameters`.
+            If None, sensible defaults are used.
+        show_progress (bool, optional):
+            Whether to display a progress bar while computing condition numbers (SVD-based) across candidate
+            tensors/modules. Disable in CI or other non-interactive environments. Defaults to True.
+    """
+    selector = KappaTuneSelector(
+        model,
+        max_dim_size_to_analyze=max_dim_size_to_analyze,
+        moe_param_suffixes=moe_param_suffixes,
+        show_progress=show_progress,
+    )
+
+    target_modules = selector.get_best_targets(top_p=top_p)
+    target_parameters = selector.get_best_target_parameters(top_p=top_p)
+
+    # Return None when there are no MoE layers (PEFT convention)
+    if not target_parameters:
+        target_parameters = None
+
+    return {
+        "target_modules": target_modules,
+        "target_parameters": target_parameters,
+    }

tasks/tasksmith-c488fc138ba1/environment/source/src/peft/import_utils.py

@@ -0,0 +1,189 @@
+# Copyright 2023-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import importlib
+import importlib.metadata as importlib_metadata
+import platform
+from functools import lru_cache
+
+import packaging.version
+import torch
+import transformers
+
+
+is_transformers_ge_v5 = packaging.version.parse(transformers.__version__) >= packaging.version.parse("5.0.0.dev0")
+
+is_transformers_ge_v5_1_0 = packaging.version.parse(transformers.__version__) >= packaging.version.parse("5.1.0")
+
+is_transformers_ge_v5_4_0 = packaging.version.parse(transformers.__version__) >= packaging.version.parse("5.4.0")
+
+is_transformers_ge_v5_6_0 = packaging.version.parse(transformers.__version__) >= packaging.version.parse("5.6.0.dev0")
+
+is_transformers_le_4_53 = packaging.version.parse(transformers.__version__) < packaging.version.parse("4.54.0.dev0")
+
+
+@lru_cache
+def is_bnb_available() -> bool:
+    return importlib.util.find_spec("bitsandbytes") is not None
+
+
+@lru_cache
+def is_bnb_4bit_available() -> bool:
+    if not is_bnb_available():
+        return False
+
+    import bitsandbytes as bnb
+
+    return hasattr(bnb.nn, "Linear4bit")
+
+
+@lru_cache
+def is_gptqmodel_available() -> bool:
+    if importlib.util.find_spec("gptqmodel") is not None:
+        GPTQMODEL_MINIMUM_VERSION = packaging.version.parse("7.0.0")
+        OPTIMUM_MINIMUM_VERSION = packaging.version.parse("1.24.0")
+        version_gptqmodel = packaging.version.parse(importlib_metadata.version("gptqmodel"))
+        if GPTQMODEL_MINIMUM_VERSION <= version_gptqmodel:
+            if is_optimum_available():
+                try:
+                    version_optimum = packaging.version.parse(importlib_metadata.version("optimum"))
+                except importlib_metadata.PackageNotFoundError:
+                    # Same idea as in diffusers:
+                    # https://github.com/huggingface/diffusers/blob/9f06a0d1a4a998ac6a463c5be728c892f95320a8/src/diffusers/utils/import_utils.py#L351-L357
+                    # It's not clear under what circumstances `importlib_metadata.version("optimum")` can raise an error
+                    # even though `importlib.util.find_spec("optimum") is not None` but it has been observed, so adding
+                    # this for precaution. If we cannot detect it, we just optimistically assume it's high enough.
+                    return True
+
+                if OPTIMUM_MINIMUM_VERSION <= version_optimum:
+                    return True
+                else:
+                    raise ImportError(
+                        f"gptqmodel requires optimum version `{OPTIMUM_MINIMUM_VERSION}` or higher. Found version `{version_optimum}`, "
+                        f"but only versions above `{OPTIMUM_MINIMUM_VERSION}` are supported"
+                    )
+            else:
+                raise ImportError(
+                    f"gptqmodel requires optimum version `{OPTIMUM_MINIMUM_VERSION}` or higher to be installed."
+                )
+        else:
+            raise ImportError(
+                f"Found an incompatible version of gptqmodel. Found version `{version_gptqmodel}`, "
+                f"but only versions `{GPTQMODEL_MINIMUM_VERSION}` or higher are supported"
+            )
+
+
+@lru_cache
+def is_optimum_available() -> bool:
+    return importlib.util.find_spec("optimum") is not None
+
+
+@lru_cache
+def is_torch_tpu_available(check_device=True) -> bool:
+    "Checks if `torch_xla` is installed and potentially if a TPU is in the environment"
+    if importlib.util.find_spec("torch_xla") is not None:
+        if check_device:
+            # We need to check if `xla_device` can be found, will raise a RuntimeError if not
+            try:
+                import torch_xla.core.xla_model as xm
+
+                _ = xm.xla_device()
+                return True
+            except RuntimeError:
+                return False
+        return True
+    return False
+
+
+@lru_cache
+def is_aqlm_available() -> bool:
+    return importlib.util.find_spec("aqlm") is not None
+
+
+@lru_cache
+def is_eetq_available() -> bool:
+    return importlib.util.find_spec("eetq") is not None
+
+
+@lru_cache
+def is_hqq_available() -> bool:
+    return importlib.util.find_spec("hqq") is not None
+
+
+@lru_cache
+def is_inc_available() -> bool:
+    return importlib.util.find_spec("neural_compressor") is not None
+
+
+@lru_cache
+def is_torchao_available() -> bool:
+    if importlib.util.find_spec("torchao") is None:
+        return False
+
+    TORCHAO_MINIMUM_VERSION = packaging.version.parse("0.16.0")
+    try:
+        torchao_version = packaging.version.parse(importlib_metadata.version("torchao"))
+    except importlib_metadata.PackageNotFoundError:
+        # Same idea as in diffusers:
+        # https://github.com/huggingface/diffusers/blob/9f06a0d1a4a998ac6a463c5be728c892f95320a8/src/diffusers/utils/import_utils.py#L351-L357
+        # It's not clear under what circumstances `importlib_metadata.version("torchao")` can raise an error even
+        # though `importlib.util.find_spec("torchao") is not None` but it has been observed, so adding this for
+        # precaution.
+        return False
+
+    if torchao_version < TORCHAO_MINIMUM_VERSION:
+        raise ImportError(
+            f"Found an incompatible version of torchao. Found version {torchao_version}, "
+            f"but only versions above {TORCHAO_MINIMUM_VERSION} are supported"
+        )
+    return True
+
+
+@lru_cache
+def is_xpu_available(check_device=False) -> bool:
+    """
+    Checks if XPU acceleration is available and potentially if a XPU is in the environment
+    """
+
+    system = platform.system()
+    if system == "Darwin":
+        return False
+    else:
+        if check_device:
+            try:
+                # Will raise a RuntimeError if no XPU is found
+                _ = torch.xpu.device_count()
+                return torch.xpu.is_available()
+            except RuntimeError:
+                return False
+        return hasattr(torch, "xpu") and torch.xpu.is_available()
+
+
+@lru_cache
+def is_diffusers_available() -> bool:
+    return importlib.util.find_spec("diffusers") is not None
+
+
+@lru_cache
+def is_te_available() -> bool:
+    return importlib.util.find_spec("transformer_engine") is not None
+
+
+@lru_cache
+def is_te_pytorch_available() -> bool:
+    if not is_te_available():
+        return False
+
+    import transformer_engine
+
+    return hasattr(transformer_engine, "pytorch")

tasks/tasksmith-c488fc138ba1/environment/source/src/peft/mapping.py

@@ -0,0 +1,92 @@
+# Copyright 2023-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Optional
+
+import torch
+
+from .utils import PeftType
+
+
+if TYPE_CHECKING:
+    from .config import PeftConfig
+    from .tuners.tuners_utils import BaseTuner
+
+
+# these will be filled by the register_peft_method function
+PEFT_TYPE_TO_CONFIG_MAPPING: dict[PeftType, type[PeftConfig]] = {}
+PEFT_TYPE_TO_TUNER_MAPPING: dict[PeftType, type[BaseTuner]] = {}
+PEFT_TYPE_TO_MIXED_MODEL_MAPPING: dict[PeftType, type[BaseTuner]] = {}
+PEFT_TYPE_TO_PREFIX_MAPPING: dict[PeftType, str] = {}
+
+
+def get_peft_config(config_dict: dict[str, Any]) -> PeftConfig:
+    """
+    Returns a Peft config object from a dictionary.
+
+    Args:
+        config_dict (`Dict[str, Any]`): Dictionary containing the configuration parameters.
+    """
+
+    return PEFT_TYPE_TO_CONFIG_MAPPING[config_dict["peft_type"]](**config_dict)
+
+
+def inject_adapter_in_model(
+    peft_config: PeftConfig,
+    model: torch.nn.Module,
+    adapter_name: str = "default",
+    low_cpu_mem_usage: bool = False,
+    state_dict: Optional[dict[str, torch.Tensor]] = None,
+) -> torch.nn.Module:
+    r"""
+    Create PEFT layers and inject them into the model in-place.
+
+    Currently the API does not support prompt learning methods and adaption prompt.
+
+    This function is similar to [`get_peft_model`] but it does not return a [`PeftModel`] instance. Instead, it returns
+    the original, mutated instance of the passed model.
+
+    Args:
+        peft_config (`PeftConfig`):
+            Configuration object containing the parameters of the PEFT model.
+        model (`torch.nn.Module`):
+            The input model where the adapter will be injected.
+        adapter_name (`str`, `optional`, defaults to `"default"`):
+            The name of the adapter to be injected, if not provided, the default adapter name is used ("default").
+        low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+            Create empty adapter weights on meta device. Useful to speed up the loading process.
+        state_dict (`dict`, *optional*, defaults to `None`)
+            If a `state_dict` is passed here, the adapters will be injected based on the entries of the state_dict.
+            This can be useful when the exact `target_modules` of the PEFT method is unknown, for instance because the
+            checkpoint was created without meta data. Note that the values from the `state_dict` are not used, only the
+            keys are used to determine the correct layers that should be adapted.
+    """
+    if peft_config.is_prompt_learning or peft_config.is_adaption_prompt:
+        raise ValueError("`create_and_replace` does not support prompt learning and adaption prompt yet.")
+
+    if peft_config.peft_type not in PEFT_TYPE_TO_TUNER_MAPPING.keys():
+        raise ValueError(
+            f"`inject_adapter_in_model` does not support {peft_config.peft_type} yet. Please use `get_peft_model`."
+        )
+
+    tuner_cls = PEFT_TYPE_TO_TUNER_MAPPING[peft_config.peft_type]
+
+    # By instantiating a peft model we are injecting randomly initialized LoRA layers into the model's modules.
+    peft_model = tuner_cls(
+        model, peft_config, adapter_name=adapter_name, low_cpu_mem_usage=low_cpu_mem_usage, state_dict=state_dict
+    )
+
+    return peft_model.model

tasks/tasksmith-c488fc138ba1/environment/source/src/peft/mapping_func.py

@@ -0,0 +1,128 @@
+# Copyright 2024-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import warnings
+from typing import Optional
+
+from transformers import PreTrainedModel
+
+from .auto import MODEL_TYPE_TO_PEFT_MODEL_MAPPING
+from .config import PeftConfig
+from .mapping import PEFT_TYPE_TO_CONFIG_MAPPING, PEFT_TYPE_TO_PREFIX_MAPPING
+from .mixed_model import PeftMixedModel
+from .peft_model import PeftModel
+from .tuners.tuners_utils import BaseTuner, BaseTunerLayer
+
+
+def get_peft_model(
+    model: PreTrainedModel,
+    peft_config: PeftConfig,
+    adapter_name: str = "default",
+    mixed: bool = False,
+    autocast_adapter_dtype: bool = True,
+    revision: Optional[str] = None,
+    low_cpu_mem_usage: bool = False,
+) -> PeftModel | PeftMixedModel:
+    """
+    Returns a Peft model object from a model and a config, where the model will be modified in-place.
+
+    Args:
+        model ([`transformers.PreTrainedModel`]):
+            Model to be wrapped.
+        peft_config ([`PeftConfig`]):
+            Configuration object containing the parameters of the Peft model.
+        adapter_name (`str`, `optional`, defaults to `"default"`):
+            The name of the adapter to be injected, if not provided, the default adapter name is used ("default").
+        mixed (`bool`, `optional`, defaults to `False`):
+            Whether to allow mixing different (compatible) adapter types.
+        autocast_adapter_dtype (`bool`, *optional*):
+            Whether to autocast the adapter dtype. Defaults to `True`. Right now, this will only cast adapter weights
+            using float16 or bfloat16 to float32, as this is typically required for stable training, and only affect
+            select PEFT tuners.
+        revision (`str`, `optional`, defaults to `main`):
+            The revision of the base model. If this isn't set, the saved peft model will load the `main` revision for
+            the base model
+        low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+            Create empty adapter weights on meta device. Useful to speed up the loading process. Leave this setting as
+            False if you intend on training the model, unless the adapter weights will be replaced by different weights
+            before training starts.
+    """
+    model_config = BaseTuner.get_model_config(model)
+    old_name = peft_config.base_model_name_or_path
+    new_name = model.__dict__.get("name_or_path", None)
+    peft_config.base_model_name_or_path = new_name
+
+    # Especially in notebook environments there could be a case that a user wants to experiment with different
+    # configuration values. However, it is likely that there won't be any changes for new configs on an already
+    # initialized PEFT model. The best we can do is warn the user about it.
+    if any(isinstance(module, BaseTunerLayer) for module in model.modules()):
+        warnings.warn(
+            "You are trying to modify a model with PEFT for a second time. If you want to reload the model with a "
+            "different config, make sure to call `.unload()` before."
+        )
+
+    if (old_name is not None) and (old_name != new_name):
+        warnings.warn(
+            f"The PEFT config's `base_model_name_or_path` was renamed from '{old_name}' to '{new_name}'. "
+            "Please ensure that the correct base model is loaded when loading this checkpoint."
+        )
+
+    if revision is not None:
+        if peft_config.revision is not None and peft_config.revision != revision:
+            warnings.warn(
+                f"peft config has already set base model revision to {peft_config.revision}, overwriting with revision {revision}"
+            )
+        peft_config.revision = revision
+
+    if (
+        (isinstance(peft_config, PEFT_TYPE_TO_CONFIG_MAPPING["LORA"]))
+        and (peft_config.init_lora_weights == "eva")
+        and not low_cpu_mem_usage
+    ):
+        warnings.warn(
+            "lora with eva initialization used with low_cpu_mem_usage=False. "
+            "Setting low_cpu_mem_usage=True can improve the maximum batch size possible for eva initialization."
+        )
+
+    prefix = PEFT_TYPE_TO_PREFIX_MAPPING.get(peft_config.peft_type)
+    if prefix and adapter_name in prefix:
+        warnings.warn(
+            f"Adapter name '{adapter_name}' should not be contained in the prefix '{prefix}'. "
+            "This may lead to reinitialization of the adapter weights during loading."
+        )
+
+    if mixed:
+        # note: PeftMixedModel does not support autocast_adapter_dtype, so don't pass it
+        return PeftMixedModel(model, peft_config, adapter_name=adapter_name)
+
+    # We explicitly exclude prompt learning here since prompt learning is specific to the task and needs special
+    # handling in the PEFT model's forward method.
+    if peft_config.task_type not in MODEL_TYPE_TO_PEFT_MODEL_MAPPING.keys() and not peft_config.is_prompt_learning:
+        return PeftModel(
+            model,
+            peft_config,
+            adapter_name=adapter_name,
+            autocast_adapter_dtype=autocast_adapter_dtype,
+            low_cpu_mem_usage=low_cpu_mem_usage,
+        )
+
+    return MODEL_TYPE_TO_PEFT_MODEL_MAPPING[peft_config.task_type](
+        model,
+        peft_config,
+        adapter_name=adapter_name,
+        autocast_adapter_dtype=autocast_adapter_dtype,
+        low_cpu_mem_usage=low_cpu_mem_usage,
+    )

tasks/tasksmith-c488fc138ba1/environment/source/src/peft/mixed_model.py

@@ -0,0 +1,473 @@
+# Copyright 2023-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import os
+from contextlib import contextmanager
+from typing import Any, Optional, Union
+
+import torch
+from accelerate.hooks import remove_hook_from_submodules
+from torch import nn
+from transformers.utils import PushToHubMixin
+
+from peft.utils.constants import DUMMY_MODEL_CONFIG
+
+from .config import PeftConfig
+from .peft_model import PeftModel
+from .tuners import MixedModel
+from .utils import _set_adapter, _set_trainable
+
+
+def _prepare_model_for_gradient_checkpointing(model: nn.Module) -> None:
+    r"""
+    Prepares the model for gradient checkpointing if necessary
+    """
+    # Note: same as PeftModel._prepare_model_for_gradient_checkpointing
+    if not getattr(model, "is_gradient_checkpointing", True):
+        return model
+
+    if not (
+        getattr(model, "is_loaded_in_8bit", False)
+        or getattr(model, "is_loaded_in_4bit", False)
+        or getattr(model, "is_quantized", False)
+    ):
+        if hasattr(model, "enable_input_require_grads"):
+            model.enable_input_require_grads()
+        elif hasattr(model, "get_input_embeddings"):
+
+            def make_inputs_require_grad(module, input, output):
+                output.requires_grad_(True)
+
+            model.get_input_embeddings().register_forward_hook(make_inputs_require_grad)
+
+
+def _check_config_compatible(peft_config: PeftConfig) -> None:
+    from .tuners.mixed import COMPATIBLE_TUNER_TYPES
+
+    if peft_config.peft_type not in COMPATIBLE_TUNER_TYPES:
+        raise ValueError(
+            f"The provided `peft_type` '{peft_config.peft_type.value}' is not compatible with the `PeftMixedModel`. "
+            f"Compatible types are: {COMPATIBLE_TUNER_TYPES}"
+        )
+
+
+class PeftMixedModel(PushToHubMixin, torch.nn.Module):
+    """
+    PeftMixedModel for loading mixing different types of adapters for inference.
+
+    This class does not support loading/saving, and it shouldn't usually be initialized directly. Instead, use
+    `get_peft_model` with the argument `mixed=True`.
+
+    > [!TIP] > Read the [Mixed adapter types](https://huggingface.co/docs/peft/en/developer_guides/mixed_models) guide
+    to learn > more about using different adapter types.
+
+    Example:
+
+    ```py
+    >>> base_model = ...  # load the base model, e.g. from transformers
+    >>> peft_model = PeftMixedModel.from_pretrained(base_model, path_to_adapter1, "adapter1").eval()
+    >>> peft_model.load_adapter(path_to_adapter2, "adapter2")
+    >>> peft_model.set_adapter(["adapter1", "adapter2"])  # activate both adapters
+    >>> peft_model(data)  # forward pass using both adapters
+    ```
+
+    Args:
+        model (`torch.nn.Module`):
+            The model to be tuned.
+        config (`PeftConfig`):
+            The config of the model to be tuned. The adapter type must be compatible.
+        adapter_name (`str`, `optional`, defaults to `"default"`):
+            The name of the first adapter.
+        low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+            Create empty adapter weights on meta device. Useful to speed up the loading process.
+    """
+
+    def __init__(self, model: nn.Module, peft_config: PeftConfig, adapter_name: str = "default") -> None:
+        super().__init__()
+        _check_config_compatible(peft_config)
+        _prepare_model_for_gradient_checkpointing(model)
+        self.modules_to_save = None
+        self.base_model = MixedModel(model, {adapter_name: peft_config}, adapter_name)
+        self.set_modules_to_save(peft_config, adapter_name)
+
+        self.config = getattr(model, "config", DUMMY_MODEL_CONFIG)
+
+        # the `pretraining_tp` is set for some models to simulate Tensor Parallelism during inference to avoid
+        # numerical differences, https://github.com/pytorch/pytorch/issues/76232 - to avoid any unexpected
+        # behavior we disable that in this line.
+        if hasattr(self.base_model, "config") and hasattr(self.base_model.config, "pretraining_tp"):
+            self.base_model.config.pretraining_tp = 1
+
+    @property
+    def peft_config(self) -> dict[str, PeftConfig]:
+        return self.base_model.peft_config
+
+    @property
+    def active_adapter(self) -> str:
+        return self.base_model.active_adapter
+
+    @property
+    def active_adapters(self) -> list[str]:
+        return self.base_model.active_adapters
+
+    def get_nb_trainable_parameters(self):
+        r"""
+        Returns the number of trainable parameters and number of all parameters in the model.
+        """
+        # note: same as PeftModel.get_nb_trainable_parameters
+        trainable_params = 0
+        all_param = 0
+        for _, param in self.named_parameters():
+            num_params = param.numel()
+            # if using DS Zero 3 and the weights are initialized empty
+            if num_params == 0 and hasattr(param, "ds_numel"):
+                num_params = param.ds_numel
+
+            # Due to the design of 4bit linear layers from bitsandbytes
+            # one needs to multiply the number of parameters by 2 to get
+            # the correct number of parameters
+            if param.__class__.__name__ == "Params4bit":
+                num_params = num_params * 2
+
+            all_param += num_params
+            if param.requires_grad:
+                trainable_params += num_params
+
+        return trainable_params, all_param
+
+    def print_trainable_parameters(self):
+        """
+        Prints the number of trainable parameters in the model.
+
+        Note: print_trainable_parameters() uses get_nb_trainable_parameters() which is different from
+        num_parameters(only_trainable=True) from huggingface/transformers. get_nb_trainable_parameters() returns
+        (trainable parameters, all parameters) of the Peft Model which includes modified backbone transformer model.
+        For techniques like LoRA, the backbone transformer model is modified in place with LoRA modules. However, for
+        prompt tuning, the backbone transformer model is unmodified. num_parameters(only_trainable=True) returns number
+        of trainable parameters of the backbone transformer model which can be different.
+        """
+        # note: same as PeftModel.print_trainable_parameters
+        trainable_params, all_param = self.get_nb_trainable_parameters()
+
+        print(
+            f"trainable params: {trainable_params:,d} || "
+            f"all params: {all_param:,d} || "
+            f"trainable%: {100 * trainable_params / all_param:.4f}"
+        )
+
+    def __getattr__(self, name: str):
+        """Forward missing attributes to the wrapped module."""
+        try:
+            return super().__getattr__(name)  # defer to nn.Module's logic
+        except AttributeError:
+            if name == "base_model":  # see #1892: prevent infinite recursion if class is not initialized
+                raise
+            return getattr(self.base_model, name)
+
+    def forward(self, *args: Any, **kwargs: Any):
+        """
+        Forward pass of the model.
+        """
+        return self.base_model(*args, **kwargs)
+
+    def generate(self, *args: Any, **kwargs: Any):
+        """
+        Generate output.
+        """
+        return self.base_model.generate(*args, **kwargs)
+
+    @contextmanager
+    def disable_adapter(self):
+        """
+        Disables the adapter module.
+        """
+        try:
+            self.base_model.disable_adapter_layers()
+            yield
+        finally:
+            self.base_model.enable_adapter_layers()
+
+    def add_adapter(
+        self,
+        adapter_name: str,
+        peft_config: PeftConfig,
+        low_cpu_mem_usage: bool = False,
+        autocast_adapter_dtype: bool = True,
+    ) -> None:
+        """
+        Add an adapter to the model based on the passed configuration.
+
+        This adapter is not trained. To load a trained adapter, check out [`PeftModel.load_adapter`].
+
+        The name for the new adapter should be unique.
+
+        The new adapter is not automatically set as the active adapter. Use [`PeftModel.set_adapter`] to set the active
+        adapter.
+
+        Args:
+            adapter_name (`str`):
+                The name of the adapter to be added.
+            peft_config ([`PeftConfig`]):
+                The configuration of the adapter to be added.
+            low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+                Create empty adapter weights on meta device. Useful to speed up the process when loading saved
+                adapters.
+
+                > [!TIP] > Don't use `low_cpu_mem_usage=True` when creating a new PEFT adapter for training (training
+                is untested > and discouraged for PeftMixedModel in general).
+            autocast_adapter_dtype (`bool`, *optional*, defaults to `True`):
+                Whether to autocast the adapter dtype. Defaults to `True`. Right now, this will only cast adapter
+                weights using float16 and bfloat16 to float32, as this is typically required for stable training, and
+                only affect select PEFT tuners. If set to `False`, the dtypes will stay the same as those of the
+                corresponding layer.
+        """
+        _check_config_compatible(peft_config)
+
+        try:
+            self.peft_config[adapter_name] = peft_config
+            self.base_model.inject_adapter(self, adapter_name, low_cpu_mem_usage=low_cpu_mem_usage)
+        except Exception:  # something went wrong, roll back
+            if adapter_name in self.peft_config:
+                del self.peft_config[adapter_name]
+            raise
+
+        self.base_model._cast_adapter_dtype(adapter_name=adapter_name, autocast_adapter_dtype=autocast_adapter_dtype)
+
+        self.set_modules_to_save(peft_config, adapter_name)
+
+    def set_modules_to_save(self, peft_config: PeftConfig, adapter_name: str) -> None:
+        if (modules_to_save := getattr(peft_config, "modules_to_save", None)) is None:
+            return
+
+        if self.modules_to_save is None:
+            self.modules_to_save = set(modules_to_save)
+        else:
+            self.modules_to_save.update(modules_to_save)
+        _set_trainable(
+            self,
+            adapter_name,
+            module_names=getattr(peft_config, "modules_to_save", None),
+            inference_mode=peft_config.inference_mode,
+        )
+
+    def set_adapter(self, adapter_name: Union[str, list[str]], inference_mode: bool = False) -> None:
+        """
+        Sets the active adapter(s) for the model.
+
+        Note that the order in which the adapters are applied during the forward pass may not be the same as the order
+        in which they are passed to this function. Instead, the order during the forward pass is determined by the
+        order in which the adapters were loaded into the model. The active adapters only determine which adapters are
+        active during the forward pass, but not the order in which they are applied.
+
+        Additionally, this function will set the specified adapter to trainable (i.e., requires_grad=True) unless
+        inference_mode is True.
+
+        Args:
+            adapter_name (str, list[str]):
+                The name(s) of the adapter(s) to set as active
+            inference_mode (bool, optional):
+                 Whether the activated adapter should be frozen (i.e. `requires_grad=False`). Default is False.
+        """
+        if isinstance(adapter_name, str):
+            adapter_name = [adapter_name]
+
+        mismatched = set(adapter_name) - set(self.peft_config.keys())
+        if mismatched:
+            raise ValueError(
+                f"Adapter(s) {sorted(mismatched)} not found, available adapters: {sorted(self.peft_config.keys())}"
+            )
+
+        self.base_model.set_adapter(adapter_name, inference_mode=inference_mode)
+        _set_adapter(self, adapter_name, inference_mode=inference_mode)
+
+    def delete_adapter(self, adapter_name: Union[str, list[str]]) -> None:
+        if isinstance(adapter_name, str):
+            adapter_name = [adapter_name]
+
+        mismatched = set(adapter_name) - set(self.peft_config.keys())
+        if mismatched:
+            raise ValueError(
+                f"Adapter(s) {sorted(mismatched)} not found, available adapters: {sorted(self.peft_config.keys())}"
+            )
+
+        self.base_model.delete_adapter(adapter_name)
+
+    def merge_and_unload(self, *args: Any, **kwargs: Any):
+        r"""
+        This method merges the adapter layers into the base model. This is needed if someone wants to use the base
+        model as a standalone model.
+
+        Args:
+            progressbar (`bool`):
+                whether to show a progressbar indicating the unload and merge process
+            safe_merge (`bool`):
+                whether to activate the safe merging check to check if there is any potential Nan in the adapter
+                weights
+            adapter_names (`List[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged. Defaults
+                to `None`.
+        """
+        return self.base_model.merge_and_unload(*args, **kwargs)
+
+    def unload(self, *args: Any, **kwargs: Any):
+        """
+        Gets back the base model by removing all the adapter modules without merging. This gives back the original base
+        model.
+        """
+        return self.base_model.unload(*args, **kwargs)
+
+    def get_layer_status(self):
+        raise TypeError(f"get_layer_status is not supported for {self.__class__.__name__}.")
+
+    def get_model_status(self):
+        raise TypeError(f"get_model_status is not supported for {self.__class__.__name__}.")
+
+    @classmethod
+    def _split_kwargs(cls, kwargs: dict[str, Any]):
+        return PeftModel._split_kwargs(kwargs)
+
+    def _check_new_adapter_config(self, peft_config: PeftConfig, is_trainable: bool) -> None:
+        return PeftModel._check_new_adapter_config(self, peft_config, is_trainable=is_trainable)
+
+    def load_adapter(self, model_id: str, adapter_name: str, *args: Any, **kwargs: Any):
+        """
+        Load a trained adapter into the model.
+
+        The name for the new adapter should be unique.
+
+        The new adapter is not automatically set as the active adapter. Use [`PeftModel.set_adapter`] to set the active
+        adapter.
+
+        Args:
+            adapter_name (`str`):
+                The name of the adapter to be added.
+            peft_config ([`PeftConfig`]):
+                The configuration of the adapter to be added.
+            is_trainable (`bool`, *optional*, defaults to `False`):
+                Whether the adapter should be trainable or not. If `False`, the adapter will be frozen and can only be
+                used for inference.
+            torch_device (`str`, *optional*, defaults to None):
+                The device to load the adapter on. If `None`, the device will be inferred.
+            autocast_adapter_dtype (`bool`, *optional*, defaults to `True`):
+                Whether to autocast the adapter dtype. Defaults to `True`. Right now, this will only cast adapter
+                weights using float16 and bfloat16 to float32, as this is typically required for stable training, and
+                only affect select PEFT tuners.
+            ephemeral_gpu_offload (`bool`, *optional*, defaults to `False`):
+                Whether to use ephemeral GPU offloading for partially loaded modules. Defaults to `False`.
+            low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+                Create empty adapter weights on meta device before loading the saved weights. Useful to speed up the
+                process.
+            kwargs: (`optional`):
+                Additional arguments to modify the way the adapter is loaded, e.g. the token for Hugging Face Hub.
+        """
+        # the low_cpu_mem_usage option is handled through kwargs
+        output = PeftModel.load_adapter(self, model_id, adapter_name, *args, **kwargs)
+        # TODO: not quite clear why this is necessary but tests fail without it
+        self.set_adapter(self.active_adapters)
+        return output
+
+    def create_or_update_model_card(self, output_dir: str):
+        raise NotImplementedError(f"Model card creation is not supported for {self.__class__.__name__} (yet).")
+
+    def save_pretrained(
+        self,
+        save_directory: str,
+        safe_serialization: bool = False,
+        selected_adapters: Optional[list[str]] = None,
+        **kwargs: Any,
+    ):
+        raise NotImplementedError(f"Saving is not supported for {self.__class__.__name__} (yet).")
+
+    @classmethod
+    def from_pretrained(
+        cls,
+        model: nn.Module,
+        model_id: str | os.PathLike,
+        adapter_name: str = "default",
+        is_trainable: bool = False,
+        config: Optional[PeftConfig] = None,
+        **kwargs: Any,
+    ):
+        r"""
+        Instantiate a PEFT mixed model from a pretrained model and loaded PEFT weights.
+
+        Note that the passed `model` may be modified inplace.
+
+        Args:
+            model (`nn.Module`):
+                The model to be adapted.
+            model_id (`str` or `os.PathLike`):
+                The name of the PEFT configuration to use. Can be either:
+                    - A string, the `model id` of a PEFT configuration hosted inside a model repo on the Hugging Face
+                      Hub.
+                    - A path to a directory containing a PEFT configuration file saved using the `save_pretrained`
+                      method (`./my_peft_config_directory/`).
+            adapter_name (`str`, *optional*, defaults to `"default"`):
+                The name of the adapter to be loaded. This is useful for loading multiple adapters.
+            is_trainable (`bool`, *optional*, defaults to `False`):
+                Whether the adapter should be trainable or not. If `False`, the adapter will be frozen and use for
+                inference
+            config ([`~peft.PeftConfig`], *optional*):
+                The configuration object to use instead of an automatically loaded configuration. This configuration
+                object is mutually exclusive with `model_id` and `kwargs`. This is useful when configuration is already
+                loaded before calling `from_pretrained`.
+            low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+                Create empty adapter weights on meta device before loading the saved weights. Useful to speed up the
+                process.
+            kwargs: (`optional`):
+                Additional keyword arguments passed along to the specific PEFT configuration class.
+        """
+        # note: adapted from PeftModel.from_pretrained
+        from .mapping import PEFT_TYPE_TO_CONFIG_MAPPING, PEFT_TYPE_TO_MIXED_MODEL_MAPPING
+
+        # load the config
+        if config is None:
+            hf_kwargs = {
+                "subfolder": kwargs.get("subfolder", None),
+                "revision": kwargs.get("revision", None),
+                "cache_dir": kwargs.get("cache_dir", None),
+                "token": kwargs.get("token", None),
+            }
+            if use_auth_token := kwargs.get("use_auth_token", None):
+                hf_kwargs["use_auth_token"] = use_auth_token
+            config = PEFT_TYPE_TO_CONFIG_MAPPING[PeftConfig._get_peft_type(model_id, **hf_kwargs)].from_pretrained(
+                model_id, **kwargs
+            )
+        elif isinstance(config, PeftConfig):
+            config.inference_mode = not is_trainable
+        else:
+            raise ValueError(f"The input config must be a PeftConfig, got {config.__class__}")
+
+        # note: this is different from PeftModel.from_pretrained
+        if config.peft_type not in PEFT_TYPE_TO_MIXED_MODEL_MAPPING:
+            raise ValueError(f"Adapter of type {config.peft_type} is not supported for mixed models.")
+
+        if (getattr(model, "hf_device_map", None) is not None) and len(
+            set(model.hf_device_map.values()).intersection({"cpu", "disk"})
+        ) > 0:
+            remove_hook_from_submodules(model)
+
+        if config.is_prompt_learning and is_trainable:
+            # note: should not be possible to reach, but just in case
+            raise ValueError("Cannot set a prompt learning adapter to trainable when loading pretrained adapter.")
+        else:
+            config.inference_mode = not is_trainable
+
+        # note: this is different from PeftModel.from_pretrained, we always return a PeftMixedModel
+        model = cls(model, config, adapter_name)
+        # the low_cpu_mem_usage option is handled through kwargs
+        model.load_adapter(model_id, adapter_name, is_trainable=is_trainable, **kwargs)
+        return model

tasks/tasksmith-c488fc138ba1/environment/source/src/peft/optimizers/__init__.py

@@ -0,0 +1,19 @@
+# Copyright 2025-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .lorafa import create_lorafa_optimizer
+from .loraplus import create_loraplus_optimizer
+
+
+__all__ = ["create_lorafa_optimizer", "create_loraplus_optimizer"]

tasks/tasksmith-c488fc138ba1/environment/source/src/peft/optimizers/lorafa.py

@@ -0,0 +1,255 @@
+# Copyright 2025-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+This module contains the implementation of the LoRA-FA optimizer.
+"""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Callable, Iterable
+
+import torch
+from accelerate.utils.imports import is_bf16_available
+from torch import autocast, nn
+from torch.optim import Optimizer
+
+from ..peft_model import PeftModel
+from ..utils.other import infer_device
+
+
+class LoraFAOptimizer(Optimizer):
+    """
+    Implements the LoRA-FA optimizer designed specifically for training Low-Rank Adaptation (LoRA) parameters
+    efficiently. Note that LoraFAOptimizer is based on adamw-hf in transformers, with only LoRA part modified. Without
+    LoRA it will fall back to adamw-hf.
+
+    Args:
+        params (Iterable[nn.parameter.Parameter]): Parameters to optimize.
+        lr (float, optional): Learning rate (default: 1e-3).
+        betas (Tuple[float, float], optional):
+            Coefficients for computing running averages of gradient and squared gradient (default: (0.9, 0.999)).
+        eps (float, optional): Term added to denominator to improve numerical stability (default: 1e-6).
+        weight_decay (float, optional): Weight decay (L2 penalty) (default: 0.0).
+        correct_bias (bool, optional): Whether to apply bias correction as in original Adam (default: True).
+
+    Args in sub-function step:
+        closure (Callable, optional): A closure that reevaluates the model and returns the loss.
+
+    Reference:
+        - LoRA-FA: https://huggingface.co/papers/2308.03303
+    """
+
+    def __init__(
+        self,
+        params: Iterable[nn.parameter.Parameter],
+        lr: float = 1e-3,
+        betas: tuple[float, float] = (0.9, 0.999),
+        eps: float = 1e-6,
+        weight_decay: float = 0.0,
+        correct_bias: bool = True,
+    ):
+        if lr < 0.0:
+            raise ValueError(f"Invalid learning rate: {lr} - should be >= 0.0")
+        if not 0.0 <= betas[0] < 1.0:
+            raise ValueError(f"Invalid beta parameter: {betas[0]} - should be in [0.0, 1.0)")
+        if not 0.0 <= betas[1] < 1.0:
+            raise ValueError(f"Invalid beta parameter: {betas[1]} - should be in [0.0, 1.0)")
+        if not 0.0 <= eps:
+            raise ValueError(f"Invalid epsilon value: {eps} - should be >= 0.0")
+        defaults = {
+            "lr": lr,
+            "betas": betas,
+            "eps": eps,
+            "weight_decay": weight_decay,
+            "correct_bias": correct_bias,
+        }
+        super().__init__(params, defaults)
+
+    @torch.no_grad()
+    def step(self, closure: Callable | None = None):
+        """
+        Performs a single optimization step.
+
+        Arguments:
+            closure (`Callable`, *optional*): A closure that reevaluates the model and returns the loss.
+        """
+        loss = None
+        if closure is not None:
+            loss = closure()
+
+        for group in self.param_groups:
+            scaling_factor = group["scaling_factor"]
+            param_list = []
+            name_list = []
+            for p, n in zip(group["params"], group["names"]):
+                # Skip non-lora no-grad module, since we need lora_A which is no-grad.
+                if "lora" not in n and p.grad is None:
+                    continue
+                grad = p.grad
+
+                if "lora" in n:
+                    param_list.append(p)
+                    name_list.append(n)
+                    if len(param_list) == 2:
+                        name = n[: n.find("lora")] + "lora"
+                    elif len(param_list) == 1:
+                        continue
+                else:
+                    name = n
+                # param_list contains a pair of A and B adapters
+                # i.e., param_list -> [A,B]
+
+                state = self.state[name]
+                # State initialization
+                if len(state) == 0:
+                    if len(param_list) == 2:
+                        state["step"] = 0
+                        # Exponential moving average of gradient values
+                        state["exp_avg_B"] = torch.zeros_like(param_list[1])
+                        # Exponential moving average of squared gradient values
+                        state["exp_avg_sq_B"] = torch.zeros_like(param_list[1])
+                    else:
+                        state["step"] = 0
+                        # Exponential moving average of gradient values
+                        state["exp_avg"] = torch.zeros_like(p)
+                        # Exponential moving average of squared gradient values
+                        state["exp_avg_sq"] = torch.zeros_like(p)
+
+                # Below is the LoRA-FA part
+                # 1. In this part, we optimize the gradient of B as:
+                #    g^B = \left(\frac{r}{\alpha}\right)^2 (A^\top A)^{-1} g_{\text{LoRA-FA}}^B
+                #    to min the func as described below:
+                #    \min_{g^B} \|\hat{g}_\text{LoRA-FA} - g\|_F^2
+                # 2. After the gradient of B is ready, update the optimizer state
+                if len(param_list) == 2:
+                    A = param_list[0]
+                    B = param_list[1]
+                    grad_B_orin = B.grad
+
+                    # projection
+                    delta = 1e-8
+
+                    # computing the inverse matrix
+                    AA_T = A @ A.T
+                    AA_T_inv = torch.linalg.pinv(AA_T + delta * torch.eye(A.shape[0]).to(A.device))
+
+                    device_type = infer_device()
+
+                    if is_bf16_available():
+                        with autocast(device_type=device_type, dtype=torch.bfloat16):
+                            grad_B = (1 / scaling_factor**2) * (grad_B_orin @ AA_T_inv)
+                    else:
+                        grad_B = (1 / scaling_factor**2) * (grad_B_orin @ AA_T_inv)
+
+                    if grad_B.dtype != B.grad.dtype:
+                        grad_B = grad_B.to(B.grad.dtype)
+
+                    exp_avg_B, exp_avg_sq_B = state["exp_avg_B"], state["exp_avg_sq_B"]
+                    beta1, beta2 = group["betas"]
+                    state["step"] += 1
+                    exp_avg_B.mul_(beta1).add_(grad_B, alpha=(1.0 - beta1))
+                    exp_avg_sq_B.mul_(beta2).addcmul_(grad_B, grad_B, value=1.0 - beta2)
+
+                    denom_B = exp_avg_sq_B.sqrt().add_(group["eps"])
+                    step_size = group["lr"]
+                    if group["correct_bias"]:  # No bias correction for Bert
+                        bias_correction1 = 1.0 - beta1 ** state["step"]
+                        bias_correction2 = 1.0 - beta2 ** state["step"]
+                        step_size = step_size * math.sqrt(bias_correction2) / bias_correction1
+                    B.addcdiv_(exp_avg_B, denom_B, value=-step_size)
+                    if group["weight_decay"] > 0.0:
+                        B.add_(B, alpha=(-group["lr"] * group["weight_decay"]))
+                    param_list = []
+                    name_list = []
+
+                # Below is the original AdamW
+                else:
+                    exp_avg, exp_avg_sq = state["exp_avg"], state["exp_avg_sq"]
+                    beta1, beta2 = group["betas"]
+
+                    state["step"] += 1
+
+                    # Decay the first and second moment running average coefficient
+                    # In-place operations to update the averages at the same time
+                    exp_avg.mul_(beta1).add_(grad, alpha=(1.0 - beta1))
+                    exp_avg_sq.mul_(beta2).addcmul_(grad, grad, value=1.0 - beta2)
+                    denom = exp_avg_sq.sqrt().add_(group["eps"])
+
+                    step_size = group["lr"]
+                    if group["correct_bias"]:  # No bias correction for Bert
+                        bias_correction1 = 1.0 - beta1 ** state["step"]
+                        bias_correction2 = 1.0 - beta2 ** state["step"]
+                        step_size = step_size * math.sqrt(bias_correction2) / bias_correction1
+
+                    p.addcdiv_(exp_avg, denom, value=-step_size)
+
+                    # Just adding the square of the weights to the loss function is *not*
+                    # the correct way of using L2 regularization/weight decay with Adam,
+                    # since that will interact with the m and v parameters in strange ways.
+                    #
+                    # Instead we want to decay the weights in a manner that doesn't interact
+                    # with the m/v parameters. This is equivalent to adding the square
+                    # of the weights to the loss with plain (non-momentum) SGD.
+                    # Add weight decay at the end (fixed version)
+                    if group["weight_decay"] > 0.0:
+                        p.add_(p, alpha=(-group["lr"] * group["weight_decay"]))
+
+        return loss
+
+
+def create_lorafa_optimizer(
+    model: PeftModel, r: int, lora_alpha: int, lr: float, weight_decay: float = 0.0, use_rslora: bool = False
+) -> Optimizer:
+    """
+    Helper function to instantiate a lorafa optimizer specifically configured for a given model using the LoRA method.
+
+    This function will:
+    - Disable gradient updates for the "lora_A" parameters (these are typically frozen during LoRA training).
+    - Compute the scaling factor based on provided `lora_alpha` and rank `r` for proper gradient projection.
+    - Create and configure parameter groups for the optimizer including specified learning rate, weight decay, and
+      additional optimizer options.
+
+    For hyper-params, LoRA-FA uses the same hyper-params as AdamW, except for the LoRA hyper-params (r, lora_alpha,
+    use_rslora). One can always use the same hyper-params such as lr and weight_decay, as AdamW in LoRA tuning.
+
+    Args:
+        model (PeftModel): The model containing LoRA-adapted parameters.
+        r (int): Rank of the LoRA decomposition.
+        lora_alpha (int): Scaling factor for LoRA parameterization.
+        lr (float): Learning rate for optimizer updates.
+        weight_decay (float): Weight decay for AdamW.
+        use_rslora (bool):
+            whether to use rslora. In rslora, the lora scaling factor becomes to lora_alpha / math.sqrt(r) instead of
+            lora_alpha / r.
+
+    Returns:
+        Optimizer: Configured lorafa optimizer instance ready for training.
+    """
+    for name, param in model.named_parameters():
+        if "lora_A" in name:
+            param.requires_grad_(False)
+    lora_scaling = lora_alpha / math.sqrt(r) if use_rslora else lora_alpha / r
+    param_groups = [
+        {
+            "params": model.parameters(),
+            "lr": lr,
+            "names": [name for name, _ in model.named_parameters()],
+            "scaling_factor": lora_scaling,
+            "betas": (0.9, 0.999),
+            "weight_decay": weight_decay,
+        }
+    ]
+    return LoraFAOptimizer(param_groups)

tasks/tasksmith-c488fc138ba1/environment/source/src/peft/optimizers/loraplus.py

@@ -0,0 +1,121 @@
+# Copyright 2024-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+This module contains the implementation of the LoraPlus optimizer.
+"""
+
+from __future__ import annotations
+
+from operator import attrgetter
+
+from torch import nn
+from torch.optim import Optimizer
+from transformers.pytorch_utils import ALL_LAYERNORM_LAYERS
+from transformers.trainer_pt_utils import get_parameter_names
+
+from ..peft_model import PeftModel
+from ..tuners.lora.layer import Embedding
+
+
+def create_loraplus_optimizer(
+    model: PeftModel, optimizer_cls: type[Optimizer], *, lr: float, loraplus_lr_ratio: float, **kwargs
+) -> Optimizer:
+    """
+    Creates a LoraPlus optimizer.
+
+    Efficient Low Rank Adaptation of Large Models: https://huggingface.co/papers/2402.12354
+
+    Reference: https://github.com/nikhil-ghosh-berkeley/loraplus/
+
+    Args:
+        model (`torch.nn.Module`): The model to be optimized.
+        optimizer_cls (`torch.optim.Optimizer`): The optimizer class to be used.
+        lr (`float`): The learning rate to be used for the optimizer.
+        loraplus_lr_ratio (`float`):
+            The ratio of learning ηB/ηA where ηA (lr) is passed in as the optimizer learning rate. Should be ≥1. Should
+            be set in tandem with the optimizer learning rate (lr); should be larger when the task is more difficult
+            and the model needs to update its features to learn well. In this case, it helps to make the learning rate
+            slightly smaller (e.g., by a factor of 2) than typical vanilla LoRA learning rates
+        loraplus_lr_embedding (optional `float`):
+            If LoRA modules are added to embedding layers your can specify a different learning rate for them. Default
+            value 1e-6.
+        kwargs (`dict`): Additional keyword arguments to be passed to the optimizer.
+
+    Returns:
+        `torch.optim.Optimizer`: An instance of the specified optimizer class configured with the model's parameters
+        organized into groups with custom learning rates.
+    """
+
+    decay_parameters = get_parameter_names(model, ALL_LAYERNORM_LAYERS)
+    decay_parameters = [name for name in decay_parameters if "bias" not in name]
+    param_groups = {
+        "groupA": {},
+        "groupB": {},
+        "groupB_no_decay": {},
+        "embedding": {},
+    }
+
+    for name, param in model.named_parameters():
+        if not param.requires_grad:
+            continue
+
+        module = attrgetter(name)(model)
+        if isinstance(module, Embedding):
+            param_groups["embedding"][name] = param
+        elif "lora_B" in name or param.ndim == 1:
+            if name in decay_parameters:
+                param_groups["groupB"][name] = param
+            else:
+                param_groups["groupB_no_decay"][name] = param
+        else:
+            param_groups["groupA"][name] = param
+
+    kwargs["lr"] = lr
+    loraplus_weight_decay = kwargs.pop("loraplus_weight_decay", 0.0)
+    loraplus_lr_embedding = kwargs.pop("loraplus_lr_embedding", 1e-6)
+
+    optimizer_grouped_parameters = [
+        {
+            "params": list(param_groups["groupA"].values()),
+            "weight_decay": loraplus_weight_decay,
+            "lr": lr,
+        },
+        {
+            "params": list(param_groups["embedding"].values()),
+            "weight_decay": loraplus_weight_decay,
+            "lr": loraplus_lr_embedding,
+        },
+        {
+            "params": list(param_groups["groupB"].values()),
+            "weight_decay": loraplus_weight_decay,
+            "lr": lr * loraplus_lr_ratio,
+        },
+        {
+            "params": list(param_groups["groupB_no_decay"].values()),
+            "weight_decay": 0.0,
+            "lr": lr * loraplus_lr_ratio,
+        },
+    ]
+
+    optimizer = optimizer_cls(optimizer_grouped_parameters, **kwargs)
+    eight_bit_names = ["Adam8bit", "AdamW8bit", "PagedAdam8bit", "PagedAdamW8bit"]
+    if optimizer_cls.__name__ in eight_bit_names:
+        import bitsandbytes
+
+        manager = bitsandbytes.optim.GlobalOptimManager.get_instance()
+        for module in model.modules():
+            if isinstance(module, nn.Embedding):
+                manager.register_module_override(module, "weight", {"optim_bits": 32})
+    return optimizer

tasks/tasksmith-c488fc138ba1/environment/source/src/peft/tuners/__init__.py

@@ -0,0 +1,174 @@
+# Copyright 2023-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .adalora import AdaLoraConfig, AdaLoraModel
+from .adamss import AdamssConfig, AdamssModel
+from .adaption_prompt import AdaptionPromptConfig, AdaptionPromptModel
+from .beft import BeftConfig, BeftModel
+from .boft import BOFTConfig, BOFTModel
+from .c3a import C3AConfig, C3AModel
+from .cartridge import CartridgeConfig, CartridgeEncoder
+from .cpt import CPTConfig, CPTEmbedding
+from .delora import DeloraConfig, DeloraModel
+from .fourierft import FourierFTConfig, FourierFTModel
+from .frod import FrodConfig, FrodModel
+from .gralora import GraloraConfig, GraloraModel
+from .hira import HiraConfig, HiraModel
+from .hra import HRAConfig, HRAModel
+from .ia3 import IA3Config, IA3Model
+from .lily import LilyConfig, LilyModel
+from .ln_tuning import LNTuningConfig, LNTuningModel
+from .loha import LoHaConfig, LoHaModel
+from .lokr import LoKrConfig, LoKrModel
+from .lora import (
+    ArrowConfig,
+    BdLoraConfig,
+    EvaConfig,
+    LoftQConfig,
+    LoraConfig,
+    LoraGAConfig,
+    LoraModel,
+    LoraRuntimeConfig,
+    MontecloraConfig,
+    VeloraConfig,
+    convert_to_lora,
+    create_arrow_model,
+    get_eva_state_dict,
+    initialize_lora_eva_weights,
+    preprocess_loraga,
+    save_as_lora,
+)
+from .miss import MissConfig, MissModel
+from .mixed import MixedModel
+from .multitask_prompt_tuning import MultitaskPromptEmbedding, MultitaskPromptTuningConfig, MultitaskPromptTuningInit
+from .oft import OFTConfig, OFTModel
+from .osf import OSFConfig, OSFModel
+from .p_tuning import PromptEncoder, PromptEncoderConfig, PromptEncoderReparameterizationType
+from .peanut import PeanutConfig, PeanutModel
+from .poly import PolyConfig, PolyModel
+from .prefix_tuning import PrefixEncoder, PrefixTuningConfig
+from .prompt_tuning import PromptEmbedding, PromptTuningConfig, PromptTuningInit
+from .psoft import PsoftConfig, PsoftModel
+from .pvera import PveraConfig, PveraModel
+from .randlora import RandLoraConfig, RandLoraModel
+from .road import RoadConfig, RoadModel
+from .shira import ShiraConfig, ShiraModel
+from .tinylora import TinyLoraConfig, TinyLoraModel
+from .trainable_tokens import TrainableTokensConfig, TrainableTokensModel
+from .vblora import VBLoRAConfig, VBLoRAModel
+from .vera import VeraConfig, VeraModel
+from .waveft import WaveFTConfig, WaveFTModel
+from .xlora import XLoraConfig, XLoraModel
+
+
+__all__ = [
+    "AdaLoraConfig",
+    "AdaLoraModel",
+    "AdamssConfig",
+    "AdamssModel",
+    "AdaptionPromptConfig",
+    "AdaptionPromptModel",
+    "ArrowConfig",
+    "BOFTConfig",
+    "BOFTModel",
+    "BdLoraConfig",
+    "BeftConfig",
+    "BeftModel",
+    "C3AConfig",
+    "C3AModel",
+    "CPTConfig",
+    "CPTEmbedding",
+    "CartridgeConfig",
+    "CartridgeEncoder",
+    "DeloraConfig",
+    "DeloraModel",
+    "EvaConfig",
+    "FourierFTConfig",
+    "FourierFTModel",
+    "FrodConfig",
+    "FrodModel",
+    "GraloraConfig",
+    "GraloraModel",
+    "HRAConfig",
+    "HRAModel",
+    "HiraConfig",
+    "HiraModel",
+    "IA3Config",
+    "IA3Model",
+    "LNTuningConfig",
+    "LNTuningModel",
+    "LilyConfig",
+    "LilyModel",
+    "LoHaConfig",
+    "LoHaModel",
+    "LoKrConfig",
+    "LoKrModel",
+    "LoftQConfig",
+    "LoraConfig",
+    "LoraGAConfig",
+    "LoraModel",
+    "LoraRuntimeConfig",
+    "MissConfig",
+    "MissModel",
+    "MixedModel",
+    "MontecloraConfig",
+    "MultitaskPromptEmbedding",
+    "MultitaskPromptTuningConfig",
+    "MultitaskPromptTuningInit",
+    "OFTConfig",
+    "OFTModel",
+    "OSFConfig",
+    "OSFModel",
+    "PeanutConfig",
+    "PeanutModel",
+    "PolyConfig",
+    "PolyModel",
+    "PrefixEncoder",
+    "PrefixTuningConfig",
+    "PromptEmbedding",
+    "PromptEncoder",
+    "PromptEncoderConfig",
+    "PromptEncoderReparameterizationType",
+    "PromptTuningConfig",
+    "PromptTuningInit",
+    "PsoftConfig",
+    "PsoftModel",
+    "PveraConfig",
+    "PveraModel",
+    "RandLoraConfig",
+    "RandLoraModel",
+    "RoadConfig",
+    "RoadModel",
+    "ShiraConfig",
+    "ShiraModel",
+    "TinyLoraConfig",
+    "TinyLoraModel",
+    "TrainableTokensConfig",
+    "TrainableTokensModel",
+    "VBLoRAConfig",
+    "VBLoRAModel",
+    "VeloraConfig",
+    "VeraConfig",
+    "VeraModel",
+    "WaveFTConfig",
+    "WaveFTModel",
+    "XLoraConfig",
+    "XLoraModel",
+    "convert_to_lora",
+    "create_arrow_model",
+    "get_eva_state_dict",
+    "initialize_lora_eva_weights",
+    "preprocess_loraga",
+    "save_as_lora",
+]

tasks/tasksmith-c488fc138ba1/environment/source/src/peft/tuners/_buffer_dict.py

@@ -0,0 +1,159 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+# Adapted from https://botorch.org/api/_modules/botorch/utils/torch.html
+
+# TODO: To be removed once (if) https://github.com/pytorch/pytorch/pull/37385 lands
+
+from __future__ import annotations
+
+import collections
+from collections import OrderedDict
+
+import torch
+from torch.nn import Module
+
+
+class BufferDict(Module):
+    r"""
+    Holds buffers in a dictionary.
+
+    BufferDict can be indexed like a regular Python dictionary, but buffers it contains are properly registered, and
+    will be visible by all Module methods. `torch.nn.BufferDict` is an **ordered** dictionary that respects
+
+    * the order of insertion, and
+    * in `torch.nn.BufferDict.update`, the order of the merged `OrderedDict` or another `torch.nn.BufferDict` (the
+      argument to `torch.nn.BufferDict.update`).
+
+    Note that `torch.nn.BufferDict.update` with other unordered mapping types (e.g., Python's plain `dict`) does not
+    preserve the order of the merged mapping.
+
+    Args:
+        buffers (iterable, optional):
+            a mapping (dictionary) of (string : `torch.Tensor`) or an iterable of key-value pairs of type (string,
+            `torch.Tensor`)
+
+    ```python
+    class MyModule(nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.buffers = nn.BufferDict({"left": torch.randn(5, 10), "right": torch.randn(5, 10)})
+
+        def forward(self, x, choice):
+            x = self.buffers[choice].mm(x)
+            return x
+    ```
+    """
+
+    def __init__(self, buffers=None, persistent: bool = False):
+        r"""
+        Args:
+            buffers (`dict`):
+                A mapping (dictionary) from string to `torch.Tensor`, or an iterable of key-value pairs of type
+                (string, `torch.Tensor`).
+        """
+        super().__init__()
+        self.persistent = persistent
+
+        if buffers is not None:
+            self.update(buffers)
+
+    def __getitem__(self, key):
+        return self._buffers[key]
+
+    def __setitem__(self, key, buffer):
+        self.register_buffer(key, buffer, persistent=self.persistent)
+
+    def __delitem__(self, key):
+        del self._buffers[key]
+
+    def __len__(self):
+        return len(self._buffers)
+
+    def __iter__(self):
+        return iter(self._buffers.keys())
+
+    def __contains__(self, key):
+        return key in self._buffers
+
+    def clear(self):
+        """Remove all items from the BufferDict."""
+        self._buffers.clear()
+
+    def pop(self, key):
+        r"""Remove key from the BufferDict and return its buffer.
+
+        Args:
+            key (`str`):
+                Key to pop from the BufferDict
+        """
+        v = self[key]
+        del self[key]
+        return v
+
+    def keys(self):
+        r"""Return an iterable of the BufferDict keys."""
+        return self._buffers.keys()
+
+    def items(self):
+        r"""Return an iterable of the BufferDict key/value pairs."""
+        return self._buffers.items()
+
+    def values(self):
+        r"""Return an iterable of the BufferDict values."""
+        return self._buffers.values()
+
+    def update(self, buffers):
+        r"""
+        Update the `torch.nn.BufferDict` with the key-value pairs from a mapping or an iterable, overwriting existing
+        keys.
+
+        Note:
+            If `buffers` is an `OrderedDict`, a `torch.nn.BufferDict`, or an iterable of key-value pairs, the order of
+            new elements in it is preserved.
+
+        Args:
+            buffers (iterable):
+                a mapping (dictionary) from string to `torch.Tensor`, or an iterable of key-value pairs of type
+                (string, `torch.Tensor`).
+        """
+        if not isinstance(buffers, collections.abc.Iterable):
+            raise TypeError(
+                "BuffersDict.update should be called with an "
+                "iterable of key/value pairs, but got " + type(buffers).__name__
+            )
+
+        if isinstance(buffers, (OrderedDict, BufferDict)):
+            for key, buffer in buffers.items():
+                self[key] = buffer
+        elif isinstance(buffers, collections.abc.Mapping):
+            for key, buffer in sorted(buffers.items()):
+                self[key] = buffer
+        else:
+            for j, p in enumerate(buffers):
+                if not isinstance(p, collections.abc.Iterable):
+                    raise TypeError(
+                        "BufferDict update sequence element #" + str(j) + " should be Iterable; is" + type(p).__name__
+                    )
+                if not len(p) == 2:
+                    raise ValueError(
+                        "BufferDict update sequence element "
+                        "#" + str(j) + " has length " + str(len(p)) + "; 2 is required"
+                    )
+                self[p[0]] = p[1]
+
+    def extra_repr(self):
+        child_lines = []
+        for k, p in self._buffers.items():
+            size_str = "x".join(str(size) for size in p.size())
+            device_type = p.device.type
+            device_str = "" if device_type == "cpu" else f" ({device_type.upper()} {p.get_device()})"
+            parastr = f"Buffer containing: [{torch.typename(p)} of size {size_str}{device_str}]"
+            child_lines.append("  (" + k + "): " + parastr)
+        tmpstr = "\n".join(child_lines)
+        return tmpstr
+
+    def __call__(self, input):
+        raise RuntimeError("BufferDict should not be called.")

tasks/tasksmith-c488fc138ba1/environment/source/src/peft/tuners/adalora/__init__.py

@@ -0,0 +1,51 @@
+# Copyright 2023-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available
+from peft.utils import register_peft_method
+
+from .config import AdaLoraConfig
+from .gptq import SVDQuantLinear
+from .layer import AdaLoraLayer, RankAllocator, SVDConv2d, SVDLinear
+from .model import AdaLoraModel
+
+
+__all__ = [
+    "AdaLoraConfig",
+    "AdaLoraLayer",
+    "AdaLoraModel",
+    "RankAllocator",
+    "SVDConv2d",
+    "SVDLinear",
+    "SVDQuantLinear",
+]
+
+
+register_peft_method(
+    name="adalora", config_cls=AdaLoraConfig, model_cls=AdaLoraModel, prefix="lora_", is_mixed_compatible=True
+)
+
+
+def __getattr__(name):
+    if (name == "SVDLinear8bitLt") and is_bnb_available():
+        from .bnb import SVDLinear8bitLt
+
+        return SVDLinear8bitLt
+
+    if (name == "SVDLinear4bit") and is_bnb_4bit_available():
+        from .bnb import SVDLinear4bit
+
+        return SVDLinear4bit
+
+    raise AttributeError(f"module {__name__} has no attribute {name}")

tasks/tasksmith-c488fc138ba1/environment/source/src/peft/tuners/adalora/bnb.py

@@ -0,0 +1,142 @@
+# Copyright 2023-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Any
+
+import torch
+
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available
+
+from .config import AdaLoraConfig
+from .layer import AdaLoraLayer
+
+
+if is_bnb_available():
+
+    class SVDLinear8bitLt(torch.nn.Module, AdaLoraLayer):
+        # Low-rank matrix for SVD-based adaptation
+        def __init__(
+            self,
+            base_layer: torch.nn.Module,
+            adapter_name: str,
+            config: AdaLoraConfig,
+            r: int = 0,
+            lora_alpha: int = 1,
+            **kwargs,
+        ) -> None:
+            super().__init__()
+            AdaLoraLayer.__init__(self, base_layer)
+            # Freezing the pre-trained weight matrix
+            self.get_base_layer().weight.requires_grad = False
+
+            self._active_adapter = adapter_name
+            self.update_layer(adapter_name, r, lora_alpha, config=config)
+
+        def forward(self, x: torch.Tensor) -> torch.Tensor:
+            # note: no check for self.merged because merging is not supported (yet)
+            result = self.base_layer(x)
+
+            if self.disable_adapters:
+                return result
+
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.lora_A.keys():
+                    continue
+                requires_conversion = not torch.is_autocast_enabled()
+                if requires_conversion:
+                    expected_dtype = result.dtype
+                    if x.dtype != torch.float32:
+                        x = x.float()
+
+                lora_A = self.lora_A[active_adapter]
+                lora_B = self.lora_B[active_adapter]
+                lora_E = self.lora_E[active_adapter]
+                dropout = self.lora_dropout[active_adapter]
+                scaling = self.scaling[active_adapter]
+                ranknum = self.ranknum[active_adapter] + 1e-5
+
+                output = dropout(x) @ (lora_A * lora_E).T @ lora_B.T
+                if requires_conversion:
+                    output = output.to(expected_dtype)
+                output = output * scaling / ranknum
+                # inplace operation on view is forbidden for MatMul8bitLtBackward, so avoid it
+                result = result + output
+            return result
+
+        def __repr__(self) -> str:
+            rep = super().__repr__()
+            return "adalora." + rep
+
+
+if is_bnb_4bit_available():
+
+    class SVDLinear4bit(torch.nn.Module, AdaLoraLayer):
+        # Low-rank matrix for SVD-based adaptation
+        def __init__(
+            self,
+            base_layer: torch.nn.Module,
+            adapter_name: str,
+            config: AdaLoraConfig,
+            r: int = 0,
+            lora_alpha: int = 1,
+            **kwargs,
+        ) -> None:
+            super().__init__()
+            AdaLoraLayer.__init__(self, base_layer)
+            # Freezing the pre-trained weight matrix
+            self.get_base_layer().weight.requires_grad = False
+
+            self._active_adapter = adapter_name
+            self.update_layer(adapter_name, r, lora_alpha, config=config)
+
+        def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+            # note: no check for self.merged because merging is not supported (yet)
+            result = self.base_layer(x, *args, **kwargs)
+
+            if self.disable_adapters:
+                return result
+
+            # As per Tim Dettmers, for 4bit, we need to defensively clone here.
+            # The reason is that in some cases, an error can occur that backprop
+            # does not work on a manipulated view. This issue may be solved with
+            # newer PyTorch versions but this would need extensive testing to be
+            # sure.
+            result = result.clone()
+
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.lora_A.keys():
+                    continue
+
+                lora_A = self.lora_A[active_adapter]
+                lora_B = self.lora_B[active_adapter]
+                lora_E = self.lora_E[active_adapter]
+                dropout = self.lora_dropout[active_adapter]
+                scaling = self.scaling[active_adapter]
+                ranknum = self.ranknum[active_adapter] + 1e-5
+
+                requires_conversion = not torch.is_autocast_enabled()
+                if requires_conversion:
+                    expected_dtype = result.dtype
+                    x = self._cast_input_dtype(x, lora_A.dtype)
+
+                output = dropout(x) @ (lora_A * lora_E).T @ lora_B.T
+                if requires_conversion:
+                    output = output.to(expected_dtype)
+                output = output * scaling / ranknum
+                result += output
+            return result
+
+        def __repr__(self) -> str:
+            rep = super().__repr__()
+            return "adalora." + rep

tasks/tasksmith-c488fc138ba1/environment/source/src/peft/tuners/adalora/config.py

@@ -0,0 +1,108 @@
+# Copyright 2023-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import warnings
+from dataclasses import dataclass, field
+from typing import Optional
+
+from peft.tuners.lora import LoraConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class AdaLoraConfig(LoraConfig):
+    """
+    This is the configuration class to store the configuration of a [`AdaLoraModel`].
+
+    AdaLoRA has three phases defined by `tinit`, `tfinal` and `total_step`.
+
+    The initial phase can be understood as a step for pre-training the adapters so that when reducing their rank, there
+    is already some information encoded that can be reduced instead of random matrices. This phase is defined by
+    supplying `tinit`.
+
+    After the initial phase is over (`tinit` steps have passed) and the final phase has not begun, AdaLoRA reduces the
+    budget of how much rank each layer is allowed to have with each step. This is where the reduction of rank is
+    happening. This goes on until `total_step - tfinal` steps are reached.
+
+    The last phase, beginning once `total_step - tfinal` steps are reached, does not change the layer ranks anymore but
+    fine-tunes the reduced-rank layers that resulted from the previous phase.
+
+    A practical example: `tinit` is 10, `tfinal` is 20, `total_step` is 100. We spend 10 steps doing pre-training
+    without rank reduction because our budget is constant (init phase), then we spend 80 (100-20) steps in the
+    reduction phase where our budget decreases step-wise and, finally, 20 steps in the final fine-tuning stage without
+    reduction.
+
+    Args:
+        target_r (`int`): The target average rank of incremental matrix.
+        init_r (`int`): The initial rank for each incremental matrix.
+        tinit (`int`): The steps of initial fine-tuning warmup.
+        tfinal (`int`): The number of steps of final fine-tuning.
+        deltaT (`int`): The time internval between two budget allocations.
+        beta1 (`float`): The hyperparameter of EMA for sensitivity smoothing.
+        beta2 (`float`): The hyperparameter of EMA for undertainty quantification.
+        orth_reg_weight (`float`): The coefficient of orthogonal regularization.
+        total_step (`int`): The total training steps that should be specified before training.
+        rank_pattern (`list`): The allocated rank for each weight matrix by RankAllocator.
+    """
+
+    target_r: int = field(default=8, metadata={"help": "Target Lora matrix dimension."})
+    init_r: int = field(default=12, metadata={"help": "Initial Lora matrix dimension."})
+    tinit: int = field(default=0, metadata={"help": "The steps of initial warmup."})
+    tfinal: int = field(default=0, metadata={"help": "The steps of final warmup."})
+    deltaT: int = field(default=1, metadata={"help": "Step interval of rank allocation."})
+    beta1: float = field(default=0.85, metadata={"help": "Hyperparameter of EMA."})
+    beta2: float = field(default=0.85, metadata={"help": "Hyperparameter of EMA."})
+    orth_reg_weight: float = field(default=0.5, metadata={"help": "The orthogonal regularization coefficient."})
+    total_step: Optional[int] = field(default=None, metadata={"help": "The total training steps."})
+    rank_pattern: Optional[dict] = field(default=None, metadata={"help": "The saved rank pattern."})
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.ADALORA
+
+        if self.use_dora:
+            raise ValueError(f"{self.peft_type} does not support DoRA.")
+
+        if self.loftq_config:
+            raise ValueError(f"{self.peft_type} does not support LOFTQ.")
+
+        self.target_modules = (
+            set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        )
+        self.exclude_modules = (
+            set(self.exclude_modules) if isinstance(self.exclude_modules, list) else self.exclude_modules
+        )
+        # if target_modules is a regex expression, then layers_to_transform should be None
+        if isinstance(self.target_modules, str) and self.layers_to_transform is not None:
+            raise ValueError("`layers_to_transform` cannot be used when `target_modules` is a str.")
+
+        # check for layers_to_transform and layers_pattern
+        if self.layers_pattern and not self.layers_to_transform:
+            raise ValueError("When `layers_pattern` is specified, `layers_to_transform` must also be specified. ")
+
+        # Check if 'r' has been set to a non-default value
+        if self.r != 8:  # 8 is the default value for 'r' in LoraConfig
+            warnings.warn(
+                "Note that `r` is not used in AdaLora and will be ignored."
+                "If you intended to set the initial rank, use `init_r` instead."
+            )
+
+        if self.total_step is None or self.total_step <= 0:
+            raise ValueError("AdaLoRA does not work when `total_step` is None, supply a value > 0.")
+
+        if self.tinit >= (self.total_step - self.tfinal):
+            raise ValueError(
+                "The supplied schedule values don't allow for a budgeting phase. Decrease `tfinal`/`tinit` or "
+                "increase `total_step`."
+            )

tasks/tasksmith-c488fc138ba1/environment/source/src/peft/tuners/adalora/gptq.py

@@ -0,0 +1,71 @@
+# Copyright 2023-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import torch
+
+from .config import AdaLoraConfig
+from .layer import AdaLoraLayer
+
+
+class SVDQuantLinear(torch.nn.Module, AdaLoraLayer):
+    def __init__(
+        self,
+        base_layer,
+        adapter_name,
+        config: AdaLoraConfig,
+        r: int = 0,
+        lora_alpha: int = 1,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        AdaLoraLayer.__init__(self, base_layer)
+
+        # self.base_layer and self.quant_linear_module are the same; we need the former for consistency and the latter
+        # for backwards compatibility
+        self.quant_linear_module = base_layer
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, lora_alpha=lora_alpha, config=config)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        result = self.quant_linear_module(x)
+
+        if self.disable_adapters:
+            return result
+
+        for active_adapter in self.active_adapters:
+            if active_adapter not in self.lora_A.keys():
+                continue
+            lora_A = self.lora_A[active_adapter]
+            lora_B = self.lora_B[active_adapter]
+            lora_E = self.lora_E[active_adapter]
+            dropout = self.lora_dropout[active_adapter]
+            scaling = self.scaling[active_adapter]
+            ranknum = self.ranknum[active_adapter] + 1e-5
+
+            requires_conversion = not torch.is_autocast_enabled()
+            if requires_conversion:
+                expected_dtype = result.dtype
+                x = self._cast_input_dtype(x, torch.float32)
+
+            output = (dropout(x) @ (lora_A * lora_E).T @ lora_B.T) * scaling / ranknum
+            # TODO: here, the dtype conversion is applied on the *whole expression*,
+            # not the intermediate result, unlike for SVDLinear8bitLT and
+            # SVDLinear4bit, is that correct?
+            if requires_conversion:
+                output = output.to(expected_dtype)
+            result += output
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "adalora." + rep

tasks/tasksmith-c488fc138ba1/environment/source/src/peft/tuners/adalora/layer.py

@@ -0,0 +1,515 @@
+# Copyright 2023-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import warnings
+from typing import Any, Optional
+
+import packaging
+import torch
+import transformers
+from torch import nn
+
+from peft.tuners.lora import LoraLayer
+from peft.tuners.tuners_utils import check_adapters_to_merge
+from peft.utils import transpose
+from peft.utils.integrations import _skip_init_on_device
+
+from .config import AdaLoraConfig
+
+
+if packaging.version.parse(transformers.__version__) >= packaging.version.parse("4.33.0"):
+    from transformers.integrations import deepspeed_config
+else:
+    from transformers.deepspeed import deepspeed_config
+
+
+class AdaLoraLayer(LoraLayer):
+    # List all names of layers that may contain adapter weights
+    # Note: ranknum doesn't need to be included as it is not an nn.Module
+    adapter_layer_names = ("lora_A", "lora_B", "lora_E", "lora_embedding_A", "lora_embedding_B")
+    # All names of other parameters that may contain adapter-related parameters
+    other_param_names = ("r", "lora_alpha", "scaling", "lora_dropout", "ranknum")
+
+    def __init__(self, base_layer: nn.Module) -> None:
+        super().__init__(base_layer)
+        self.lora_E = nn.ParameterDict({})
+        self.lora_A = nn.ParameterDict({})
+        self.lora_B = nn.ParameterDict({})
+        self.ranknum = nn.ParameterDict({})
+
+    def update_layer(self, adapter_name: str, r: int, lora_alpha: int, config: AdaLoraConfig, **kwargs) -> None:
+        lora_dropout = config.lora_dropout
+        init_lora_weights = config.init_lora_weights
+        inference_mode = config.inference_mode
+        if r < 0:
+            # note: r == 0 is allowed for AdaLora, see #1539
+            raise ValueError(f"`r` should be a positive integer or 0, but the value passed is {r}")
+
+        self.r[adapter_name] = r
+        self.lora_alpha[adapter_name] = lora_alpha
+        if lora_dropout > 0.0:
+            lora_dropout_layer = nn.Dropout(p=lora_dropout)
+        else:
+            lora_dropout_layer = nn.Identity()
+
+        self.lora_dropout[adapter_name] = lora_dropout_layer
+        # Actual trainable parameters
+        # Right singular vectors
+        self.lora_A[adapter_name] = nn.Parameter(torch.randn(r, self.in_features))
+        # Singular values
+        self.lora_E[adapter_name] = nn.Parameter(torch.randn(r, 1))
+        # Left singular vectors
+        self.lora_B[adapter_name] = nn.Parameter(torch.randn(self.out_features, r))
+        # The current rank. ranknum is deterministic (always set to float(r)) and is not saved
+        # in the adapter state_dict, so under low_cpu_mem_usage=True it can't be restored from a
+        # checkpoint and must stay off the meta device. Two places need to skip the meta dispatch:
+        #   1) creation, otherwise the Parameter is registered on meta from the start;
+        #   2) the subsequent _move_adapter_to_device_of_base_layer call, because moving the
+        #      ParameterDict entry re-registers it via Module.__setattr__ → register_parameter,
+        #      which inside init_empty_weights would send the tensor back to meta.
+        with _skip_init_on_device():
+            self.ranknum[adapter_name] = nn.Parameter(torch.randn(1), requires_grad=False)
+            self.ranknum[adapter_name].data.fill_(float(r))
+            self.ranknum[adapter_name].requires_grad = False
+            self.scaling[adapter_name] = lora_alpha if lora_alpha > 0 else float(r)
+            if init_lora_weights:
+                self.reset_lora_parameters(adapter_name)
+
+            self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+    def reset_lora_parameters(self, adapter_name):
+        if adapter_name in self.lora_A.keys():
+            nn.init.zeros_(self.lora_E[adapter_name])
+            nn.init.normal_(self.lora_A[adapter_name], mean=0.0, std=0.02)
+            nn.init.normal_(self.lora_B[adapter_name], mean=0.0, std=0.02)
+
+
+class SVDLinear(nn.Module, AdaLoraLayer):
+    # SVD-based adaptation by a dense layer
+    def __init__(
+        self,
+        base_layer: nn.Module,
+        adapter_name: str,
+        config: AdaLoraConfig,
+        r: int = 0,
+        lora_alpha: int = 1,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        AdaLoraLayer.__init__(self, base_layer)
+        # Freezing the pre-trained weight matrix
+        self.get_base_layer().weight.requires_grad = False
+
+        self.fan_in_fan_out = config.fan_in_fan_out
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, lora_alpha, config=config)
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`List[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged. Defaults
+                to `None`.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        for active_adapter in adapter_names:
+            base_layer = self.get_base_layer()
+            if active_adapter in self.lora_A.keys():
+                if safe_merge:
+                    # Note that safe_merge will be slower than the normal merge
+                    # because of the copy operation.
+                    orig_weights = base_layer.weight.data.clone()
+                    orig_weights += self.get_delta_weight(active_adapter)
+
+                    if not torch.isfinite(orig_weights).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    base_layer.weight.data = orig_weights
+                else:
+                    base_layer.weight.data += self.get_delta_weight(active_adapter)
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        """
+        This method unmerges all merged adapter layers from the base weights.
+        """
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self.lora_A.keys():
+                self.get_base_layer().weight.data -= self.get_delta_weight(active_adapter)
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        return (
+            transpose(self.lora_B[adapter] @ (self.lora_A[adapter] * self.lora_E[adapter]), self.fan_in_fan_out)
+            * self.scaling[adapter]
+            / (self.ranknum[adapter] + 1e-5)
+        )
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            result = self.base_layer(x, *args, **kwargs)
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.lora_A.keys():
+                    continue
+                lora_A = self.lora_A[active_adapter]
+                lora_B = self.lora_B[active_adapter]
+                lora_E = self.lora_E[active_adapter]
+                dropout = self.lora_dropout[active_adapter]
+                scaling = self.scaling[active_adapter]
+                ranknum = self.ranknum[active_adapter] + 1e-5
+
+                x = self._cast_input_dtype(x, lora_A.dtype)
+                result += (dropout(x) @ (lora_A * lora_E).T @ lora_B.T) * scaling / ranknum
+
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "adalora." + rep
+
+
+class SVDConv2d(nn.Module, AdaLoraLayer):
+    # SVD-based adaptation by a Conv2d layer
+    def __init__(
+        self,
+        base_layer: nn.Module,
+        adapter_name: str,
+        config: AdaLoraConfig,
+        r: int = 0,
+        lora_alpha: int = 1,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        AdaLoraLayer.__init__(self, base_layer)
+        self.get_base_layer().weight.requires_grad = False
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, lora_alpha, config=config)
+
+    def update_layer(self, adapter_name: str, r: int, lora_alpha: int, config: AdaLoraConfig, **kwargs) -> None:
+        lora_dropout = config.lora_dropout
+        init_lora_weights = config.init_lora_weights
+        inference_mode = config.inference_mode
+        if r < 0:
+            raise ValueError(f"`r` should be a positive integer or 0, but the value passed is {r}")
+
+        self.r[adapter_name] = r
+        self.lora_alpha[adapter_name] = lora_alpha
+        if lora_dropout > 0.0:
+            lora_dropout_layer = nn.Dropout(p=lora_dropout)
+        else:
+            lora_dropout_layer = nn.Identity()
+        self.lora_dropout[adapter_name] = lora_dropout_layer
+
+        base = self.get_base_layer()
+        k = base.kernel_size[0] * base.kernel_size[1]
+        # Right singular vectors: (r, in_channels * kH * kW)
+        self.lora_A[adapter_name] = nn.Parameter(torch.randn(r, self.in_features * k))
+        # Singular values: (r, 1)
+        self.lora_E[adapter_name] = nn.Parameter(torch.randn(r, 1))
+        # Left singular vectors: (out_channels, r)
+        self.lora_B[adapter_name] = nn.Parameter(torch.randn(self.out_features, r))
+        # Current rank — see note in AdaLoraLayer.update_layer about _skip_init_on_device.
+        with _skip_init_on_device():
+            self.ranknum[adapter_name] = nn.Parameter(torch.randn(1), requires_grad=False)
+            self.ranknum[adapter_name].data.fill_(float(r))
+            self.ranknum[adapter_name].requires_grad = False
+            self.scaling[adapter_name] = lora_alpha if lora_alpha > 0 else float(r)
+            if init_lora_weights:
+                self.reset_lora_parameters(adapter_name)
+
+            self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`List[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged. Defaults
+                to `None`.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            return
+
+        for active_adapter in adapter_names:
+            base_layer = self.get_base_layer()
+            if active_adapter in self.lora_A.keys():
+                if safe_merge:
+                    orig_weights = base_layer.weight.data.clone()
+                    orig_weights += self.get_delta_weight(active_adapter)
+
+                    if not torch.isfinite(orig_weights).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    base_layer.weight.data = orig_weights
+                else:
+                    base_layer.weight.data += self.get_delta_weight(active_adapter)
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        """
+        This method unmerges all merged adapter layers from the base weights.
+        """
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self.lora_A.keys():
+                self.get_base_layer().weight.data -= self.get_delta_weight(active_adapter)
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        delta = (
+            self.lora_B[adapter]
+            @ (self.lora_A[adapter] * self.lora_E[adapter])
+            * self.scaling[adapter]
+            / (self.ranknum[adapter] + 1e-5)
+        )
+        return delta.reshape(self.get_base_layer().weight.shape)
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            result = self.base_layer(x, *args, **kwargs)
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.lora_A.keys():
+                    continue
+                lora_A = self.lora_A[active_adapter]
+                lora_B = self.lora_B[active_adapter]
+                lora_E = self.lora_E[active_adapter]
+                dropout = self.lora_dropout[active_adapter]
+                scaling = self.scaling[active_adapter]
+                ranknum = self.ranknum[active_adapter] + 1e-5
+
+                x = self._cast_input_dtype(x, lora_A.dtype)
+                base = self.get_base_layer()
+                delta_w = (lora_B @ (lora_A * lora_E) * scaling / ranknum).reshape(base.weight.shape)
+                # Use in-place add so result keeps its original dtype (matches SVDLinear);
+                # otherwise result would be upcast to lora_A.dtype and break subsequent fp16/bf16 ops.
+                result += nn.functional.conv2d(
+                    dropout(x),
+                    delta_w,
+                    stride=base.stride,
+                    padding=base.padding,
+                    dilation=base.dilation,
+                    groups=base.groups,
+                )
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "adalora." + rep
+
+
+class RankAllocator:
+    """
+    The RankAllocator for AdaLoraModel. Paper: https://openreview.net/pdf?id=lq62uWRJjiY
+
+    Args:
+        config ([`AdaLoraConfig`]): The configuration of the AdaLora model.
+        model: the model that we apply AdaLoRA to.
+
+    """
+
+    def __init__(self, model, peft_config, adapter_name):
+        self.peft_config = peft_config
+        self.adapter_name = adapter_name
+        self.beta1 = peft_config.beta1
+        self.beta2 = peft_config.beta2
+        assert self.beta1 > 0 and self.beta1 < 1
+        assert self.beta2 > 0 and self.beta2 < 1
+
+        self.reset_ipt()
+        self._set_budget_scheduler(model)
+
+    def set_total_step(self, total_step):
+        self.peft_config.total_step = total_step
+
+    def reset_ipt(self):
+        self.ipt = {}
+        self.exp_avg_ipt = {}
+        self.exp_avg_unc = {}
+
+    def _set_budget_scheduler(self, model):
+        self.init_bgt = 0
+        self.name_set = set()
+        for n, p in model.named_parameters():
+            if f"lora_A.{self.adapter_name}" in n:
+                self.init_bgt += p.size(0)
+                self.name_set.add(n.replace("lora_A", "%s"))
+        self.name_set = sorted(self.name_set)
+        # The total final rank budget
+        self.target_bgt = self.peft_config.target_r * len(self.name_set)
+
+    def budget_schedule(self, step: int):
+        tinit = self.peft_config.tinit
+        tfinal = self.peft_config.tfinal
+        total_step = self.peft_config.total_step
+        # Initial warmup
+        if step <= tinit:
+            budget = self.init_bgt
+            mask_ind = False
+        # Final fine-tuning
+        elif step > total_step - tfinal:
+            budget = self.target_bgt
+            mask_ind = True
+        else:
+            # Budget decreasing with a cubic scheduler
+            mul_coeff = 1 - (step - tinit) / (total_step - tfinal - tinit)
+            budget = int((self.init_bgt - self.target_bgt) * (mul_coeff**3) + self.target_bgt)
+            mask_ind = step % self.peft_config.deltaT == 0
+        return budget, mask_ind
+
+    def update_ipt(self, model):
+        # Update the sensitivity and uncertainty for every weight
+        for n, p in model.named_parameters():
+            if "lora_" in n and self.adapter_name in n:
+                if n not in self.ipt:
+                    self.ipt[n] = torch.zeros_like(p)
+                    self.exp_avg_ipt[n] = torch.zeros_like(p)
+                    self.exp_avg_unc[n] = torch.zeros_like(p)
+                with torch.no_grad():
+                    if deepspeed_config() is not None:
+                        import deepspeed
+
+                        grad = deepspeed.utils.safe_get_full_grad(p)
+                        self.ipt[n] = (p * grad).abs().detach()
+                    else:
+                        self.ipt[n] = (p * p.grad).abs().detach()
+                    # Sensitivity smoothing
+                    self.exp_avg_ipt[n] = self.beta1 * self.exp_avg_ipt[n] + (1 - self.beta1) * self.ipt[n]
+                    # Uncertainty quantification
+                    self.exp_avg_unc[n] = (
+                        self.beta2 * self.exp_avg_unc[n] + (1 - self.beta2) * (self.ipt[n] - self.exp_avg_ipt[n]).abs()
+                    )
+
+    def _element_score(self, n):
+        return self.exp_avg_ipt[n] * self.exp_avg_unc[n]
+
+    def _combine_ipt(self, ipt_E, ipt_AB):
+        ipt_AB = ipt_AB.sum(dim=1, keepdim=False)
+        sum_ipt = ipt_E.view(-1) + ipt_AB.view(-1)
+        return sum_ipt
+
+    def mask_to_budget(self, model, budget):
+        value_ipt = {}
+        vector_ipt = {}
+        triplet_ipt = {}
+        # Get the importance score for A, E, B
+        for n, p in model.named_parameters():
+            if f"lora_A.{self.adapter_name}" in n:
+                entry_ipt = self._element_score(n)
+                comb_ipt = torch.mean(entry_ipt, dim=1, keepdim=True)
+                name_m = n.replace("lora_A", "%s")
+                if name_m not in vector_ipt:
+                    vector_ipt[name_m] = [comb_ipt]
+                else:
+                    vector_ipt[name_m].append(comb_ipt)
+            if f"lora_B.{self.adapter_name}" in n:
+                entry_ipt = self._element_score(n)
+                comb_ipt = torch.mean(entry_ipt, dim=0, keepdim=False).view(-1, 1)
+                name_m = n.replace("lora_B", "%s")
+                if name_m not in vector_ipt:
+                    vector_ipt[name_m] = [comb_ipt]
+                else:
+                    vector_ipt[name_m].append(comb_ipt)
+            if f"lora_E.{self.adapter_name}" in n:
+                entry_ipt = self._element_score(n)
+                name_m = n.replace("lora_E", "%s")
+                value_ipt[name_m] = entry_ipt
+
+        all_score = []
+        # Calculate the score for each triplet
+        for name_m in vector_ipt:
+            ipt_E = value_ipt[name_m]
+            ipt_AB = torch.cat(vector_ipt[name_m], dim=1)
+            sum_ipt = self._combine_ipt(ipt_E, ipt_AB)
+            name_E = name_m % "lora_E"
+            triplet_ipt[name_E] = sum_ipt.view(-1, 1)
+            all_score.append(sum_ipt.view(-1))
+
+        # Get the threshold by ranking ipt
+        mask_threshold = torch.kthvalue(
+            torch.cat(all_score),
+            k=self.init_bgt - budget,
+        )[0].item()
+
+        rank_pattern = {}
+        # Mask the unimportant triplets
+        with torch.no_grad():
+            for n, p in model.named_parameters():
+                if f"lora_E.{self.adapter_name}" in n:
+                    p.masked_fill_(triplet_ipt[n] <= mask_threshold, 0.0)
+                    rank_pattern[n] = (~(triplet_ipt[n] <= mask_threshold)).view(-1).tolist()
+        return rank_pattern
+
+    def update_and_allocate(self, model, global_step, force_mask=False):
+        # # Update the importance score and allocate the budget
+        if global_step < self.peft_config.total_step - self.peft_config.tfinal:
+            self.update_ipt(model)
+        budget, mask_ind = self.budget_schedule(global_step)
+        # Allocate the budget according to importance scores
+        if mask_ind or force_mask:
+            rank_pattern = self.mask_to_budget(model, budget)
+        else:
+            rank_pattern = None
+        return budget, rank_pattern
+
+    def mask_using_rank_pattern(self, model, rank_pattern):
+        # Mask the unimportant triplets
+        is_adapter_name_truncated = False
+        if self.adapter_name not in next(iter(rank_pattern.keys())):
+            is_adapter_name_truncated = True
+
+        with torch.no_grad():
+            for n, p in model.named_parameters():
+                if f"lora_E.{self.adapter_name}" in n:
+                    key = n if not is_adapter_name_truncated else n.replace(f".{self.adapter_name}", "")
+                    mask = torch.Tensor(rank_pattern[key]).unsqueeze(-1).to(p.device)
+                    p.masked_fill_(~mask.bool(), 0.0)

tasks/tasksmith-c488fc138ba1/environment/source/src/peft/tuners/adalora/model.py

@@ -0,0 +1,349 @@
+# Copyright 2023-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import warnings
+
+import torch
+from transformers.pytorch_utils import Conv1D
+
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available
+from peft.tuners.lora import LoraConfig, LoraModel
+from peft.tuners.tuners_utils import BaseTunerLayer, get_device_map
+from peft.utils import (
+    TRANSFORMERS_MODELS_TO_ADALORA_TARGET_MODULES_MAPPING,
+    _freeze_adapter,
+    _get_submodules,
+    get_gptqmodel_quant_linear,
+    get_quantization_config,
+)
+from peft.utils.integrations import gather_params_ctx
+
+from .gptq import SVDQuantLinear
+from .layer import AdaLoraLayer, RankAllocator, SVDConv2d, SVDLinear
+
+
+class AdaLoraModel(LoraModel):
+    """
+    Creates AdaLoRA (Adaptive LoRA) model from a pretrained transformers model. Paper:
+    https://openreview.net/forum?id=lq62uWRJjiY
+
+    Args:
+        model ([`transformers.PreTrainedModel`]): The model to be adapted.
+        config ([`AdaLoraConfig`]): The configuration of the AdaLora model.
+        adapter_name (`str`): The name of the adapter, defaults to `"default"`.
+        low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+            Create empty adapter weights on meta device. Useful to speed up the loading process.
+
+    Returns:
+        `torch.nn.Module`: The AdaLora model.
+
+    Example:
+        ```py
+        >>> from transformers import AutoModelForSeq2SeqLM
+        >>> from peft import AdaLoraConfig, get_peft_model
+
+        >>> config = AdaLoraConfig(
+        ...     peft_type="ADALORA",
+        ...     task_type="SEQ_2_SEQ_LM",
+        ...     init_r=12,
+        ...     lora_alpha=32,
+        ...     target_modules=["q", "v"],
+        ...     lora_dropout=0.01,
+        ...     total_step=1000,
+        ... )
+        >>> model = AutoModelForSeq2SeqLM.from_pretrained("t5-base")
+        >>> adalora_model = get_peft_model(model, config)
+        ```
+
+    **Attributes**:
+        - **model** ([`transformers.PreTrainedModel`]) -- The model to be adapted.
+        - **peft_config** ([`AdaLoraConfig`]): The configuration of the AdaLora model.
+    """
+
+    # Note: don't redefine prefix or tuner_layer_cls here, it should be inherited from LoraModel
+    target_module_mapping = TRANSFORMERS_MODELS_TO_ADALORA_TARGET_MODULES_MAPPING
+
+    def __init__(self, model, config, adapter_name, **kwargs):
+        super().__init__(model, config, adapter_name, **kwargs)
+
+        traininable_mode_counter = 0
+        for peft_config in self.peft_config.values():
+            if not peft_config.inference_mode:
+                traininable_mode_counter += 1
+
+        if traininable_mode_counter > 1:
+            raise ValueError(
+                "AdaLoraModel supports only 1 trainable adapter. "
+                "When using multiple adapters, set inference_mode to True for all adapters except the one you want to train."
+            )
+
+        if self.peft_config[adapter_name].inference_mode:
+            _freeze_adapter(self.model, adapter_name)
+        else:
+            self.trainable_adapter_name = adapter_name
+            self.rankallocator = RankAllocator(self.model, self.peft_config[adapter_name], self.trainable_adapter_name)
+
+    def _check_new_adapter_config(self, config: LoraConfig) -> None:
+        """
+        A helper method to check the config when a new adapter is being added.
+
+        Raise a ValueError if there is something wrong with the config or if it conflicts with existing adapters.
+
+        """
+        super()._check_new_adapter_config(config)
+
+        traininable_mode_counter = 0
+        for config_ in self.peft_config.values():
+            if not config_.inference_mode:
+                traininable_mode_counter += 1
+
+        if traininable_mode_counter > 1:
+            raise ValueError(
+                f"{self.__class__.__name__} supports only 1 trainable adapter. "
+                "When using multiple adapters, set inference_mode to True for all adapters except the one "
+                "you want to train."
+            )
+
+    def _create_and_replace(
+        self,
+        lora_config,
+        adapter_name,
+        target,
+        target_name,
+        parent,
+        current_key,
+    ):
+        kwargs = {
+            "r": lora_config.init_r,
+            "lora_alpha": lora_config.lora_alpha,
+            "loaded_in_8bit": getattr(self.model, "is_loaded_in_8bit", False),
+            "loaded_in_4bit": getattr(self.model, "is_loaded_in_4bit", False),
+        }
+        if (kwargs["loaded_in_8bit"] or kwargs["loaded_in_4bit"]) and not is_bnb_available():
+            raise ImportError(
+                "To use AdaLora with 8-bit quantization, please install the `bitsandbytes` package. "
+                "You can install it with `pip install bitsandbytes`."
+            )
+
+        quantization_config = get_quantization_config(self.model, method="gptq")
+        if quantization_config is not None:
+            kwargs["gptq_quantization_config"] = quantization_config
+
+        # If it is not an AdaLoraLayer, create a new module, else update it with new adapters
+        if not isinstance(target, AdaLoraLayer):
+            device_map = get_device_map(self.model)
+            new_module = self._create_new_module(lora_config, adapter_name, target, device_map=device_map, **kwargs)
+            if adapter_name not in self.active_adapters:
+                # adding an additional adapter: it is not automatically trainable
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+        else:
+            target.update_layer(
+                adapter_name,
+                lora_config.init_r,
+                lora_config.lora_alpha,
+                config=lora_config,
+            )
+
+    @staticmethod
+    def _create_new_module(lora_config, adapter_name, target, device_map=None, **kwargs):
+        # avoid eager bnb import
+        if is_bnb_available():
+            import bitsandbytes as bnb
+
+            from .bnb import SVDLinear8bitLt
+        if is_bnb_4bit_available():
+            from .bnb import SVDLinear4bit
+
+        gptq_quantization_config = kwargs.get("gptq_quantization_config", None)
+
+        QuantLinear = get_gptqmodel_quant_linear(gptq_quantization_config, device_map=device_map)
+
+        loaded_in_8bit = kwargs.pop("loaded_in_8bit", False)
+        loaded_in_4bit = kwargs.pop("loaded_in_4bit", False)
+
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        if loaded_in_8bit and isinstance(target_base_layer, bnb.nn.Linear8bitLt):
+            kwargs.update(
+                {
+                    "has_fp16_weights": target_base_layer.state.has_fp16_weights,
+                    "threshold": target_base_layer.state.threshold,
+                    "index": target_base_layer.index,
+                }
+            )
+            new_module = SVDLinear8bitLt(target, adapter_name, config=lora_config, **kwargs)
+        elif loaded_in_4bit and is_bnb_4bit_available() and isinstance(target_base_layer, bnb.nn.Linear4bit):
+            fourbit_kwargs = kwargs.copy()
+            fourbit_kwargs.update(
+                {
+                    "compute_dtype": target_base_layer.compute_dtype,
+                    "compress_statistics": target_base_layer.weight.compress_statistics,
+                    "quant_type": target_base_layer.weight.quant_type,
+                }
+            )
+            new_module = SVDLinear4bit(target, adapter_name, config=lora_config, **fourbit_kwargs)
+        elif QuantLinear is not None and isinstance(target, QuantLinear):
+            new_module = SVDQuantLinear(target, adapter_name, config=lora_config, **kwargs)
+        else:
+            if isinstance(target_base_layer, torch.nn.Linear):
+                if lora_config.fan_in_fan_out:
+                    warnings.warn(
+                        "fan_in_fan_out is set to True but the target module is `torch.nn.Linear`. "
+                        "Setting fan_in_fan_out to False."
+                    )
+                    lora_config.fan_in_fan_out = False
+            elif isinstance(target_base_layer, Conv1D):
+                if not lora_config.fan_in_fan_out:
+                    warnings.warn(
+                        "fan_in_fan_out is set to False but the target module is `Conv1D`. "
+                        "Setting fan_in_fan_out to True."
+                    )
+                    lora_config.fan_in_fan_out = True
+            elif not isinstance(target_base_layer, torch.nn.Conv2d):
+                raise ValueError(
+                    f"Target module {target} is not supported. "
+                    f"Currently, only `torch.nn.Linear`, `Conv1D`, and `torch.nn.Conv2d` are supported."
+                )
+            if isinstance(target_base_layer, torch.nn.Conv2d):
+                new_module = SVDConv2d(target, adapter_name, config=lora_config, **kwargs)
+            else:
+                new_module = SVDLinear(target, adapter_name, config=lora_config, **kwargs)
+
+        return new_module
+
+    def forward(self, *args, **kwargs):
+        outputs = self.model.forward(*args, **kwargs)
+
+        if (getattr(outputs, "loss", None) is not None) and isinstance(outputs.loss, torch.Tensor):
+            # Calculate the orthogonal regularization
+            orth_reg_weight = self.peft_config[self.trainable_adapter_name].orth_reg_weight
+
+            if orth_reg_weight <= 0:
+                raise ValueError("orth_reg_weight should be greater than 0. ")
+
+            regu_loss = 0
+            num_param = 0
+            for n, p in self.model.named_parameters():
+                if ("lora_A" in n or "lora_B" in n) and self.trainable_adapter_name in n:
+                    if p.shape == torch.Size([0]):
+                        with gather_params_ctx(p, fwd_module=self):
+                            para_cov = p @ p.T if "lora_A" in n else p.T @ p
+                    else:
+                        para_cov = p @ p.T if "lora_A" in n else p.T @ p
+                    I = torch.eye(*para_cov.size(), out=torch.empty_like(para_cov))  # noqa: E741
+                    I.requires_grad = False
+                    num_param += 1
+                    regu_loss += torch.norm(para_cov - I, p="fro")
+            if num_param > 0:
+                regu_loss = regu_loss / num_param
+            else:
+                regu_loss = 0
+            outputs.loss += orth_reg_weight * regu_loss
+        return outputs
+
+    def resize_modules_by_rank_pattern(self, rank_pattern, adapter_name):
+        lora_config = self.peft_config[adapter_name]
+        for name, rank_idx in rank_pattern.items():
+            if isinstance(rank_idx, list):
+                rank = sum(rank_idx)
+            elif isinstance(rank_idx, torch.Tensor):
+                rank_idx = rank_idx.view(-1)
+                rank = rank_idx.sum().item()
+            else:
+                raise TypeError("Unexpected type of rank_idx")
+            key = ".".join(name.split(".")[0:-2]) if adapter_name in name else ".".join(name.split(".")[0:-1])
+            _, target, _ = _get_submodules(self.model, key)
+            lora_E_weights = target.lora_E[adapter_name][rank_idx]
+            lora_A_weights = target.lora_A[adapter_name][rank_idx]
+            lora_B_weights = target.lora_B[adapter_name][:, rank_idx]
+            ranknum = target.ranknum[adapter_name]
+            target.update_layer(
+                adapter_name,
+                rank,
+                lora_config.lora_alpha,
+                config=lora_config,
+            )
+            with torch.no_grad():
+                if rank > 0:
+                    target.lora_E[adapter_name].copy_(lora_E_weights)
+                    target.lora_A[adapter_name].copy_(lora_A_weights)
+                    target.lora_B[adapter_name].copy_(lora_B_weights)
+                    # The scaling is exactly as the previous
+                    target.ranknum[adapter_name].copy_(ranknum)
+
+    def resize_state_dict_by_rank_pattern(self, rank_pattern, state_dict, adapter_name):
+        for name, rank_idx in rank_pattern.items():
+            rank = sum(rank_idx)
+            prefix = ".".join(name.split(".")[0:-2]) if adapter_name in name else ".".join(name.split(".")[0:-1])
+            for layer in ["lora_E", "lora_A", "lora_B"]:
+                key = f"base_model.model.{prefix}.{layer}.{adapter_name}"
+                if layer != "lora_B":
+                    state_dict[key] = (
+                        state_dict[key][rank_idx] if rank != state_dict[key].shape[0] else state_dict[key]
+                    )
+                else:
+                    state_dict[key] = (
+                        state_dict[key][:, rank_idx] if rank != state_dict[key].shape[1] else state_dict[key]
+                    )
+        return state_dict
+
+    def update_and_allocate(self, global_step):
+        """
+        This method updates Adalora budget and mask.
+
+        This should be called in every training step after `loss.backward()` and before `zero_grad()`.
+
+        `tinit`, `tfinal` and `deltaT` are handled with in the method.
+
+        Args:
+            global_step (`int`): The current training step, it is used to calculate adalora budget.
+
+        Example:
+
+        ```python
+        >>> loss = model(**input).loss
+        >>> loss.backward()
+        >>> optimizer.step()
+        >>> model.base_model.update_and_allocate(i_step)
+        >>> optimizer.zero_grad()
+        ```
+        """
+        lora_config = self.peft_config[self.trainable_adapter_name]
+        # Update the importance score and allocate the budget
+        if global_step < lora_config.total_step - lora_config.tfinal:
+            _, rank_pattern = self.rankallocator.update_and_allocate(self.model, global_step)
+            if rank_pattern:
+                lora_config.rank_pattern = rank_pattern
+        # Finalize the budget allocation
+        elif global_step == lora_config.total_step - lora_config.tfinal:
+            _, rank_pattern = self.rankallocator.update_and_allocate(self.model, global_step, force_mask=True)
+            # for some reason, this freezes the trainable parameters and nothing gets updates
+            # self.resize_modules_by_rank_pattern(rank_pattern, self.trainable_adapter_name)
+            lora_config.rank_pattern = rank_pattern
+            self.rankallocator.reset_ipt()
+        # Currently using inefficient way to mask the unimportant weights using the rank pattern
+        #  due to problem mentioned above
+        elif global_step > lora_config.total_step - lora_config.tfinal:
+            self.rankallocator.mask_using_rank_pattern(self.model, lora_config.rank_pattern)
+        # Pass the function and do forward propagation
+        else:
+            return
+
+    def add_weighted_adapter(self, *args, **kwargs):
+        """This method is not supported for AdaLoRA, use LoRA instead."""
+        raise TypeError(f"{self.__class__.__name__} does not support add_weighted_adapter method.")

tasks/tasksmith-c488fc138ba1/environment/source/src/peft/tuners/adamss/__init__.py

@@ -0,0 +1,32 @@
+# Copyright 2026-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from peft.utils import register_peft_method
+
+from .config import AdamssConfig
+from .layer import AdamssLayer, Linear
+from .model import AdamssModel
+
+
+__all__ = [
+    "AdamssConfig",
+    "AdamssLayer",
+    "AdamssModel",
+    "Linear",
+]
+
+# Register Adamss as a PEFT method
+register_peft_method(
+    name="adamss", config_cls=AdamssConfig, model_cls=AdamssModel, prefix="adamss_", is_mixed_compatible=False
+)

tasks/tasksmith-c488fc138ba1/environment/source/src/peft/tuners/adamss/asa_callback.py

@@ -0,0 +1,90 @@
+# Copyright 2026-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+ASA (Adaptive Subspace Allocation) Callback for HuggingFace Trainer.
+
+This is a thin wrapper around [`AdamssModel.update_and_allocate`]. All ASA logic (importance accumulation, global top-K
+masking, importance reset) lives in [`AdamssModel.update_and_allocate`] so that users with custom training loops can
+call it directly without needing this callback.
+
+Important:
+    To avoid circular imports between peft and transformers, this callback is NOT exported from the top-level `peft`
+    package. Import it directly:
+
+    ```python
+    from peft.tuners.adamss.asa_callback import AdamssAsaCallback
+    ```
+"""
+
+from transformers import TrainerCallback, TrainerControl, TrainerState, TrainingArguments
+
+
+class AdamssAsaCallback(TrainerCallback):
+    """
+    Trainer callback for Adaptive Subspace Allocation (ASA).
+
+    This callback delegates to [`AdamssModel.update_and_allocate`] on every optimizer step so that ASA "just works"
+    with HuggingFace `Trainer`.
+
+    All ASA parameters (`asa_target_subspaces`, `init_warmup`, `final_warmup`, `mask_interval`, etc.) are read from the
+    [`AdamssConfig`] that was used to create the model – there is nothing to configure on the callback itself.
+
+    For custom training loops **without** Trainer, call `model.base_model.update_and_allocate(global_step)` directly
+    instead.
+
+    Example:
+
+    ```python
+    from peft import AdamssConfig, get_peft_model
+    from peft.tuners.adamss.asa_callback import AdamssAsaCallback
+    from transformers import Trainer
+
+    config = AdamssConfig(
+        r=100,
+        num_subspaces=10,
+        subspace_rank=3,
+        use_asa=True,
+        asa_target_subspaces=5,
+        init_warmup=50,
+        final_warmup=1000,
+        mask_interval=100,
+    )
+    model = get_peft_model(base_model, config)
+
+    trainer = Trainer(
+        model=model,
+        callbacks=[AdamssAsaCallback()],
+        # ...,
+    )
+    trainer.train()
+    ```
+    """
+
+    def on_optimizer_step(
+        self,
+        args: TrainingArguments,
+        state: TrainerState,
+        control: TrainerControl,
+        **kwargs,
+    ):
+        """Called after optimizer.step() – delegates to model.update_and_allocate()."""
+        model = kwargs.get("model")
+        if model is not None:
+            # Resolve to the AdamssModel (works for both PeftModel and raw base_model)
+            base_model = getattr(model, "base_model", model)
+            if hasattr(base_model, "update_and_allocate"):
+                base_model.update_and_allocate(state.global_step)
+
+        return super().on_optimizer_step(args=args, state=state, control=control)

tasks/tasksmith-c488fc138ba1/environment/source/src/peft/tuners/adamss/config.py

@@ -0,0 +1,349 @@
+# Copyright 2026-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Literal, Optional, Union
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class AdamssConfig(PeftConfig):
+    """
+    Configuration class for Adamss (Adaptive Multi-Subspaces) method.
+
+    AdaMSS is a parameter-efficient fine-tuning method that decomposes weight matrices using SVD and clusters the
+    decomposed space into multiple trainable subspaces. It learns low-rank updates within these subspaces while keeping
+    the original weights frozen.
+
+    Args:
+        r (`int`):
+            Total rank for SVD decomposition (denoted as R in the paper). This determines how many singular vectors are
+            used to represent the weight matrix before clustering. Higher values capture more information from the
+            original weights but require more computation and memory. Lower values provide stronger regularization.
+            Typical values range from 50 to 500. Default is 100.
+
+        num_subspaces (`int`):
+            Number of subspaces (K) to cluster the SVD-decomposed space into. Each subspace learns independent low-rank
+            updates. Increasing this value allows finer-grained adaptation but increases the number of trainable
+            parameters proportionally. When using ASA (Adaptive Subspace Allocation), this determines the initial
+            number of subspaces before pruning. Typical values range from 3 to 10. Default is 5.
+
+        subspace_rank (`int`):
+            The rank (r_i) for each trainable subspace. This controls the capacity of each subspace to learn
+            adaptations. Higher values increase expressiveness but also increase trainable parameters. Total trainable
+            parameters scale as O(num_subspaces * subspace_rank * (in_dim + out_dim) / num_subspaces). For most tasks,
+            values of 1-4 work well. Default is 1.
+
+        target_modules (`Optional[Union[list[str], str]]`):
+            The names of the modules to apply AdaMSS to. If specified, only these modules will be adapted. Can be a
+            list of exact module names or a regex expression. For example, `['q_proj', 'v_proj']` for attention layers,
+            or `'.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'` for regex matching.
+
+        modules_to_save (`Optional[list[str]]`):
+            List of modules apart from AdaMSS layers to be set as trainable and saved in the final checkpoint. These
+            modules will be fully fine-tuned (not just low-rank). Required for randomly initialized heads like
+            `classifier` or `score` in classification tasks.
+
+        init_weights (`Literal["orthogonal"]`):
+            Initialization method for AdaMSS trainable weights. Currently only "orthogonal" is supported, which uses
+            orthogonal initialization for the B matrices (output projection). The A matrices are initialized to zero to
+            ensure the model starts from the pretrained weights. Set to None to skip initialization when loading from a
+            checkpoint. Default is "orthogonal".
+
+        layers_to_transform (`Optional[Union[list[int], int]]`):
+            Specific layer indices to apply AdaMSS to. If specified, only these layers will be adapted, useful for
+            experimenting with which layers benefit most from adaptation. Can be a single integer or a list of
+            integers.
+
+        layers_pattern (`Optional[Union[list[str], str]]`):
+            Pattern to match layer names when `layers_to_transform` is specified. Used to extract layer indices from
+            module names that don't follow the common pattern.
+
+        use_asa (`bool`):
+            Whether to enable Adaptive Subspace Allocation (ASA). When enabled, ASA dynamically prunes less important
+            subspaces during training based on gradient information, reducing the effective number of parameters while
+            maintaining performance. Requires integration with a training callback. Default is False.
+
+        asa_target_subspaces (`int`):
+            Target total number of active subspaces across all layers when ASA is enabled. ASA will progressively prune
+            subspaces until this target is reached. Lower values result in more aggressive pruning and fewer trainable
+            parameters. Should be less than `num_subspaces * num_target_modules`. Typical values range from 20 to 100
+            depending on model size. Default is 50.
+
+        init_warmup (`int`):
+            Number of training steps to wait before starting ASA pruning. During warmup, all subspaces remain active to
+            allow importance scores to stabilize. Higher values give more time for accurate importance estimation but
+            delay pruning. Typical values range from 50 to 200. Default is 50.
+
+        final_warmup (`int`):
+            Training step at which ASA completes pruning and reaches `asa_target_subspaces` active subspaces. The
+            pruning is distributed between `init_warmup` and `final_warmup`. Should be set based on total training
+            steps; typically 1/3 to 1/2 of total training steps. Default is 1000.
+
+        mask_interval (`int`):
+            Number of training steps between ASA mask updates. Lower values allow more frequent adaptation but increase
+            overhead. Higher values provide more stable importance estimates between updates. Typical values range from
+            50 to 200. Default is 100.
+
+        asa_importance_beta (`float`):
+            Exponential moving average (EMA) coefficient for smoothing subspace importance scores. Higher values
+            (closer to 1.0) give more weight to historical importance, providing stability. Lower values make
+            importance more responsive to recent gradients. Typical values range from 0.8 to 0.95. Default is 0.85.
+
+        asa_uncertainty_beta (`float`):
+            EMA coefficient for smoothing importance uncertainty estimates. Controls how quickly uncertainty adapts to
+            gradient variance. Similar to asa_importance_beta, higher values provide more stable estimates. Typical
+            values range from 0.8 to 0.95. Default is 0.85.
+
+        asa_schedule_exponent (`float`):
+            Schedule exponent controlling the decay rate from total subspaces to `asa_target_subspaces` during ASA
+            warmup. Higher values result in faster initial pruning (more aggressive early reduction), while lower
+            values provide a more gradual, linear-like decay. The formula is: current_active_subspaces =
+            asa_target_subspaces + (asa_total_subspaces - asa_target_subspaces) * (progress ** exponent). Typical
+            values range from 1.0 (linear) to 5.0 (aggressive). Default is 3.0.
+
+        use_dynamic_rank (`bool`):
+            Whether to dynamically determine subspace ranks based on singular value magnitudes. When True, each
+            subspace's rank is determined by counting singular values above a threshold, allowing different subspaces
+            to have different effective ranks. When False, all subspaces use the fixed `subspace_rank`. Default is
+            False.
+
+        svd_threshold (`float`):
+            Threshold ratio for dynamic rank selection, only used when `use_dynamic_rank=True`. A singular value is
+            considered significant if it exceeds `threshold * max_singular_value`. Higher values result in lower
+            effective ranks (more aggressive truncation). Typical values range from 0.05 to 0.2. Default is 0.1 (10% of
+            max).
+    """
+
+    r: int = field(
+        default=100,
+        metadata={
+            "help": (
+                "Total rank for SVD decomposition (R in the paper). Higher values capture more "
+                "information but require more computation. The actual rank is clamped to "
+                "min(r, in_features, out_features). Typical values: 50-500. Default: 100."
+            )
+        },
+    )
+    num_subspaces: int = field(
+        default=5,
+        metadata={
+            "help": (
+                "Number of subspaces (K) to cluster the SVD space into. Each subspace learns "
+                "independent low-rank updates. Increasing this allows finer-grained adaptation "
+                "but increases trainable parameters. Typical values: 3-10. Default: 5."
+            )
+        },
+    )
+    subspace_rank: int = field(
+        default=1,
+        metadata={
+            "help": (
+                "Rank (r_i) for each trainable subspace. Higher values increase expressiveness "
+                "but also increase parameters. For most tasks, values of 1-4 work well. Default: 1."
+            )
+        },
+    )
+    target_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of module names or regex expression of the module names to replace with AdaMSS. "
+                "For example, ['q_proj', 'v_proj'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'. "
+                "For Vision Transformers, typically ['query', 'value']."
+            )
+        },
+    )
+    init_weights: Optional[Literal["orthogonal"]] = field(
+        default="orthogonal",
+        metadata={
+            "help": (
+                "Initialization method for AdaMSS trainable weights. Currently only 'orthogonal' "
+                "is supported, which uses orthogonal initialization for B matrices. A matrices "
+                "are initialized to zero to start from pretrained weights. Set to None to skip "
+                "initialization when loading from a checkpoint. Default: 'orthogonal'."
+            )
+        },
+    )
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of modules apart from AdaMSS layers to be set as trainable and saved in the final checkpoint. "
+                "For example, in Sequence Classification or Token Classification tasks, "
+                "the final layer `classifier/score` are randomly initialized and as such need to be trainable and saved."
+            )
+        },
+    )
+    layers_to_transform: Optional[Union[list[int], int]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "Specific layer indices to apply AdaMSS to. If specified, only these layers will "
+                "be adapted, useful for experimenting with which layers benefit most. Can be a "
+                "single integer or a list of integers. Default: None (adapt all matching layers)."
+            )
+        },
+    )
+    layers_pattern: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "Pattern to match layer names when `layers_to_transform` is specified. Used to "
+                "extract layer indices from module names that don't follow common patterns."
+            )
+        },
+    )
+    # ASA (Adaptive Subspace Allocation) parameters
+    use_asa: bool = field(
+        default=False,
+        metadata={
+            "help": (
+                "Whether to enable Adaptive Subspace Allocation (ASA). When enabled, ASA dynamically "
+                "prunes less important subspaces during training based on gradient information, "
+                "reducing parameters while maintaining performance. Requires a training callback. "
+                "Default: False."
+            )
+        },
+    )
+    asa_target_subspaces: int = field(
+        default=50,
+        metadata={
+            "help": (
+                "Target total number of active subspaces across all layers when ASA is enabled. "
+                "ASA progressively prunes subspaces until this target is reached. Lower values "
+                "result in more aggressive pruning. Typical values: 20-100. Default: 50."
+            )
+        },
+    )
+    init_warmup: int = field(
+        default=50,
+        metadata={
+            "help": (
+                "Training steps to wait before starting ASA pruning. During warmup, all subspaces "
+                "remain active to allow importance scores to stabilize. Higher values give more "
+                "time for accurate estimation. Typical values: 50-200. Default: 50."
+            )
+        },
+    )
+    final_warmup: int = field(
+        default=1000,
+        metadata={
+            "help": (
+                "Training step at which ASA completes pruning and reaches asa_target_subspaces. "
+                "Should be set based on total training steps; typically 1/3 to 1/2 of total steps. "
+                "Default: 1000."
+            )
+        },
+    )
+    mask_interval: int = field(
+        default=100,
+        metadata={
+            "help": (
+                "Training steps between ASA mask updates. Lower values allow more frequent "
+                "adaptation but increase overhead. Higher values provide more stable estimates. "
+                "Typical values: 50-200. Default: 100."
+            )
+        },
+    )
+    asa_importance_beta: float = field(
+        default=0.85,
+        metadata={
+            "help": (
+                "EMA coefficient for smoothing subspace importance scores during ASA. Higher "
+                "values (closer to 1.0) give more weight to historical importance, providing "
+                "stability. Lower values make importance more responsive to recent gradients. "
+                "Typical values: 0.8-0.95. Default: 0.85."
+            )
+        },
+    )
+    asa_uncertainty_beta: float = field(
+        default=0.85,
+        metadata={
+            "help": (
+                "EMA coefficient for smoothing importance uncertainty estimates during ASA. "
+                "Controls how quickly uncertainty adapts to gradient variance. Higher values "
+                "provide more stable estimates. Typical values: 0.8-0.95. Default: 0.85."
+            )
+        },
+    )
+    asa_schedule_exponent: float = field(
+        default=3.0,
+        metadata={
+            "help": (
+                "Schedule exponent controlling the decay rate from total subspaces to "
+                "asa_target_subspaces. Higher values result in faster initial pruning (aggressive "
+                "early reduction), lower values provide gradual linear-like decay. Formula: "
+                "current_active_subspaces = asa_target_subspaces + (total - target) * (progress ** exponent). "
+                "Typical values: 1.0 (linear) to 5.0 (aggressive). Default: 3.0."
+            )
+        },
+    )
+    # Dynamic rank selection parameters
+    use_dynamic_rank: bool = field(
+        default=False,
+        metadata={
+            "help": (
+                "Whether to dynamically determine subspace ranks based on singular value magnitudes. "
+                "When True, each subspace's rank is determined by counting singular values above "
+                "a threshold, allowing different subspaces to have different effective ranks. "
+                "When False (default), all subspaces use the fixed subspace_rank. Default: False."
+            )
+        },
+    )
+    svd_threshold: float = field(
+        default=0.1,
+        metadata={
+            "help": (
+                "Threshold ratio for dynamic rank selection (only used when use_dynamic_rank=True). "
+                "A singular value is significant if it exceeds threshold * max_singular_value. "
+                "Higher values result in lower effective ranks (more aggressive truncation). "
+                "Typical values: 0.05-0.2. Default: 0.1 (10% of max)."
+            )
+        },
+    )
+    random_seed: int = field(
+        default=0,
+        metadata={
+            "help": (
+                "Seed used to deterministically create and rebuild the adapter weights, so that a saved adapter "
+                "reproduces its outputs after loading. Default: 0."
+            )
+        },
+    )
+
+    def __post_init__(self):
+        self.peft_type = PeftType.ADAMSS
+        self.target_modules = (
+            set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        )
+        super().__post_init__()
+
+        # Normalize init_weights: convert False to None for backward compatibility
+        if self.init_weights is False:
+            self.init_weights = None
+
+        # Validate initialization method
+        if self.init_weights not in ["orthogonal", None]:
+            raise ValueError(f"init_weights must be 'orthogonal' or None, got {self.init_weights}")
+
+        # Early check for scikit-learn availability
+        try:
+            import sklearn  # noqa: F401
+        except ImportError:
+            raise ImportError("scikit-learn is required for AdaMSS. Please install it with: pip install scikit-learn")

tasks/tasksmith-c488fc138ba1/environment/source/src/peft/tuners/adamss/layer.py

@@ -0,0 +1,668 @@
+# Copyright 2026-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import warnings
+from typing import Optional
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+from peft.tuners._buffer_dict import BufferDict
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+
+from .config import AdamssConfig
+from .utils import clustering_Z, get_trainable_subspaces, seg_locations, slice_pca
+
+
+class AdamssLayer(BaseTunerLayer):
+    """
+    Base Adamss layer that stores adapter-specific information.
+    """
+
+    # All names of layers that may contain adapter weights (trainable or frozen)
+    # Use ModuleDict for proper state_dict key format that PEFT's save/load can handle
+    # Only include trainable parameter containers here (not buffers)
+    # adamss_newB is a buffer (frozen), not a trainable parameter
+    adapter_layer_names = ("adamss_A", "adamss_B")
+    # other_param_names specifies additional non-tensor metadata
+    other_param_names = (
+        "num_subspaces",
+        "train_subspace_index",
+        "seg_result",
+        "scatter_index",
+        "exp_avg_ipt_A",
+        "exp_avg_ipt_B",
+        "exp_avg_unc_A",
+        "exp_avg_unc_B",
+    )
+
+    def __init__(self, base_layer: nn.Module, **kwargs) -> None:
+        self.base_layer = base_layer
+        # Adapter-specific attributes
+        # Use ModuleDict containing ParameterList for proper state_dict keys (e.g., adamss_A.default.0)
+        self.adamss_A = nn.ModuleDict({})  # Will contain ParameterList per adapter
+        self.adamss_B = nn.ModuleDict({})  # Will contain ParameterList per adapter
+        # Use BufferDict for frozen projection matrix (keys like adamss_newB.default)
+        self.adamss_newB = BufferDict(persistent=True)
+        self.num_subspaces = {}
+        self.train_subspace_index = {}
+        self.seg_result = {}
+        self.scatter_index = {}
+        # ASA importance tracking (per-adapter lists indexed by subspace)
+        self.exp_avg_ipt_A = {}
+        self.exp_avg_ipt_B = {}
+        self.exp_avg_unc_A = {}
+        self.exp_avg_unc_B = {}
+        self._disable_adapters = False
+        self.merged_adapters = []
+
+    def reset_importance(self, adapter_name: str) -> None:
+        """
+        Clear stored importance stats for an adapter.
+
+        Called after each masking interval to restart EMA accumulation for the next importance scoring window. Without
+        the reset the scores from early training steps would dominate later masking decisions.
+        """
+        if adapter_name in self.exp_avg_ipt_A:
+            n = len(self.exp_avg_ipt_A[adapter_name])
+            self.exp_avg_ipt_A[adapter_name] = [None] * n
+            self.exp_avg_ipt_B[adapter_name] = [None] * n
+            self.exp_avg_unc_A[adapter_name] = [None] * n
+            self.exp_avg_unc_B[adapter_name] = [None] * n
+
+    def update_importance(
+        self, adapter_name: str, importance_beta: float = 0.85, uncertainty_beta: float = 0.85
+    ) -> None:
+        """
+        Update importance scores using current gradients.
+
+        Called by [`AdamssModel.update_and_allocate`] (which is in turn called by [`AdamssAsaCallback`] when using
+        HuggingFace `Trainer`).
+
+        Args:
+            adapter_name: Name of the adapter to update importance for.
+            importance_beta: EMA coefficient for importance averaging (0.8-0.95 typical).
+            uncertainty_beta: EMA coefficient for uncertainty averaging (0.8-0.95 typical).
+        """
+        if adapter_name not in self.exp_avg_ipt_A:
+            return
+        if adapter_name not in self.adamss_A:
+            return
+
+        param_list_A = self.adamss_A[adapter_name]
+        param_list_B = self.adamss_B[adapter_name]
+
+        ipt_A = self.exp_avg_ipt_A[adapter_name]
+        ipt_B = self.exp_avg_ipt_B[adapter_name]
+        unc_A = self.exp_avg_unc_A[adapter_name]
+        unc_B = self.exp_avg_unc_B[adapter_name]
+
+        for i in range(self.num_subspaces[adapter_name]):
+            for param_list, ipt_list, unc_list in [
+                (param_list_A, ipt_A, unc_A),
+                (param_list_B, ipt_B, unc_B),
+            ]:
+                param = param_list[i]
+                if param.grad is not None:
+                    if ipt_list[i] is None:
+                        ipt_list[i] = torch.zeros_like(param, requires_grad=False)
+                        unc_list[i] = torch.zeros_like(param, requires_grad=False)
+
+                    # Calculate importance: |w * g|
+                    ipt = (param * param.grad).abs().detach()
+
+                    # Update uncertainty BEFORE updating importance (matches adamss_pkg)
+                    diff = (ipt - ipt_list[i]).abs()
+                    unc_list[i].mul_(uncertainty_beta).add_(diff, alpha=1 - uncertainty_beta)
+
+                    # Then update importance
+                    ipt_list[i].mul_(importance_beta).add_(ipt, alpha=1 - importance_beta)
+
+    def update_layer(
+        self,
+        adapter_name: str,
+        r: int,
+        config: AdamssConfig,
+        **kwargs,
+    ) -> None:
+        """
+        Update layer with Adamss adapter.
+
+        This method initializes the Adamss decomposition for the weight matrix using SVD, clustering, and QR
+        initialization.
+        """
+        num_subspaces = config.num_subspaces
+        subspace_rank = config.subspace_rank
+        init_weights = config.init_weights
+        use_asa = config.use_asa
+        inference_mode = config.inference_mode
+        use_dynamic_rank = config.use_dynamic_rank
+        svd_threshold = config.svd_threshold
+
+        # Get the base weight info
+        weight = self.get_base_layer().weight
+        bias = self.get_base_layer().bias
+        device = weight.device
+        dtype = weight.dtype
+        _, in_features = weight.shape
+
+        # Adjust in_features for bias column
+        if bias is not None:
+            in_features += 1
+
+        # Prepare weight tensor (add bias as extra column if present)
+        if bias is not None:
+            weight_with_bias = torch.cat((weight, bias.unsqueeze(1)), dim=1)
+        else:
+            weight_with_bias = weight
+
+        # Reshape to 4D tensor for slice_pca: (1, 1, out_features, in_features)
+        weight_tensor = weight_with_bias.unsqueeze(0).unsqueeze(0).to(torch.float32).to(device)
+
+        # Perform SVD decomposition with diagnostics in case of failure
+        try:
+            res = slice_pca(weight_tensor, r, device, torch.float32, random_seed=config.random_seed)
+        except Exception as e:
+            raise RuntimeError(
+                f"slice_pca raised an exception for layer {adapter_name} (shape={tuple(weight_tensor.shape)}, dtype={weight_tensor.dtype}, device={device}): {e}"
+            ) from e
+
+        VVT, UU = res
+
+        # Cluster the column space
+        cluster_idx, effective_num_subspaces = clustering_Z(UU[0, 0, :, :], num_subspaces, 10)
+
+        # Get segment locations
+        seg_result = seg_locations(cluster_idx)
+
+        # Get trainable subspace indices
+        train_subspace_index = get_trainable_subspaces(effective_num_subspaces)
+
+        # Store metadata
+        self.num_subspaces[adapter_name] = effective_num_subspaces
+        self.train_subspace_index[adapter_name] = train_subspace_index
+        self.seg_result[adapter_name] = seg_result
+
+        # Store projection matrix in BufferDict (frozen, device-aware)
+        self.adamss_newB[adapter_name] = VVT[0, 0, :, :].detach().to(dtype)
+
+        # Use user-specified subspace_rank
+        rank_per_subspace = subspace_rank
+
+        # Initialize trainable subspace parameters
+        # Collect parameters in lists, then create ParameterList for proper state_dict keys
+        A_params = []
+        B_params = []
+
+        for i in range(self.num_subspaces[adapter_name]):
+            subspace_idx = train_subspace_index[i]
+            seg_indices = seg_result[subspace_idx]
+
+            # Extract subspace data: use ALL r columns from SVD (not just r/K)
+            # This matches adamss_pkg where A matrices have shape (rank_i, r)
+            subspace_data = UU[0, 0, seg_indices, :r]
+            # subspace_data shape: (len(seg_indices), r)
+
+            # Determine actual rank based on configuration
+            if use_dynamic_rank:
+                # Compute Gram matrix Z = subspace_data @ subspace_data.T
+                Z_row = subspace_data @ subspace_data.T  # (len(seg_indices), len(seg_indices))
+
+                # Compute SVD to get row space decomposition
+                _U_row, S_row, _V_row = torch.svd_lowrank(Z_row, q=min(Z_row.shape), niter=2)
+
+                # Dynamic rank selection using SVD threshold
+                # Dynamically determine actual rank using configurable threshold
+                # Following adamss_pkg: num_ii_jj = min((S > threshold * S[0]).sum().item(), args.adamss_ri)
+                threshold_mask = S_row > svd_threshold * S_row[0]
+                actual_rank = min(threshold_mask.sum().item(), subspace_rank, len(S_row))
+
+                # Handle edge case: ensure at least rank 1
+                if actual_rank == 0:
+                    actual_rank = 1
+
+            else:
+                # Fixed rank: match adamss_pkg behavior exactly
+                # adamss_pkg uses: num_ii_jj = min(len(seg_result[indx]), args.adamss_ri)
+                actual_rank = min(len(seg_indices), subspace_rank)
+
+                # Ensure at least rank 1
+                if actual_rank == 0:
+                    actual_rank = 1
+
+            # Initialize A using QR decomposition to match adamss_pkg exactly
+            # adamss_pkg: Q, R = torch.linalg.qr((UU[seg_result[indx],:]).T @ A[i], mode='reduced')
+            # where A[i] is U from SVD of subspace Gram matrix
+
+            # First, compute Gram matrix for this subspace
+            Z_subspace = subspace_data @ subspace_data.T  # (len(seg_indices), len(seg_indices))
+
+            # SVD of Gram matrix to get A_intermediate
+            U_gram, _S_gram, _ = torch.svd_lowrank(Z_subspace, q=min(Z_subspace.shape[0], actual_rank), niter=2)
+            A_intermediate = U_gram[:, :actual_rank]  # (len(seg_indices), actual_rank)
+
+            # Now apply QR decomposition: (UU[seg_indices, :r]).T @ A_intermediate
+            # UU[0, 0, seg_indices, :r] is subspace_data with shape (len(seg_indices), r)
+            matrix_for_qr = subspace_data.T @ A_intermediate  # (r, actual_rank)
+            Q, _R = torch.linalg.qr(matrix_for_qr, mode="reduced")
+
+            # A_init is Q.T to match adamss_pkg
+            A_init = Q.T.contiguous()  # (actual_rank, r)
+
+            # Initialize B matrix
+            # When init_weights='orthogonal', use zeros for identity operation (standard training init)
+            # When init_weights=None/False, use random values so adapter produces non-zero effect
+            if init_weights == "orthogonal":
+                # Zero initialization - adapter produces identity at start
+                # Note: A parameters may not update in step 1 since ∂Loss/∂A ∝ B and B=0
+                # But after step 1, B becomes non-zero and A will get gradients in step 2+
+                B_init = torch.zeros(len(seg_indices), actual_rank, dtype=dtype, device=device)
+            else:
+                # Random initialization for testing - produces non-zero adapter output
+                B_init = torch.randn(len(seg_indices), actual_rank, dtype=dtype, device=device) * 0.01
+
+            # Collect A and B parameters
+            A_params.append(nn.Parameter(A_init.to(dtype)))
+            B_params.append(nn.Parameter(B_init.to(dtype)))
+
+        # Create ParameterLists and store in ModuleDict
+        # This creates state_dict keys like 'adamss_A.default.0', 'adamss_A.default.1', etc.
+        self.adamss_A[adapter_name] = nn.ParameterList(A_params)
+        self.adamss_B[adapter_name] = nn.ParameterList(B_params)
+
+        # Initialize ASA tracking if enabled
+        if use_asa:
+            n = effective_num_subspaces
+            self.exp_avg_ipt_A[adapter_name] = [None] * n
+            self.exp_avg_ipt_B[adapter_name] = [None] * n
+            self.exp_avg_unc_A[adapter_name] = [None] * n
+            self.exp_avg_unc_B[adapter_name] = [None] * n
+
+            # Hooks are not used; importance is updated explicitly via update_importance
+            # to match adamss_pkg behavior (using accumulated gradients).
+
+        # Compute scatter_index for forward pass
+        self.scatter_index[adapter_name] = torch.cat(
+            [
+                self.seg_result[adapter_name][self.train_subspace_index[adapter_name][i]]
+                for i in range(self.num_subspaces[adapter_name])
+            ],
+            dim=0,
+        ).long()
+
+        # Move adapter to device of base layer (important for low_cpu_mem_usage support)
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+
+        # Set requires_grad via parent class set_adapter (works with ParameterList)
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+
+class Linear(nn.Module, AdamssLayer):
+    """
+    Adamss-adapted Linear layer.
+    """
+
+    def __init__(
+        self,
+        base_layer: nn.Module,
+        adapter_name: str,
+        r: int,
+        config: AdamssConfig,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        AdamssLayer.__init__(self, base_layer, **kwargs)
+
+        # Set in_features and out_features from base layer (required for PEFT compatibility)
+        self.in_features = base_layer.in_features
+        self.out_features = base_layer.out_features
+
+        # Initialize the adapter
+        self.update_layer(
+            adapter_name,
+            r,
+            config=config,
+            **kwargs,
+        )
+        self._active_adapter = adapter_name
+        self.dtype = base_layer.weight.dtype
+
+    def _load_from_state_dict(
+        self, state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs
+    ):
+        """Handle shape mismatches that arise when loading checkpoints.
+
+        AdaMSS B parameter shapes depend on KMeans clustering of the weight matrix. KMeans uses a fixed `random_state`
+        so results should be deterministic, but this override acts as a safety net in case sklearn changes clustering
+        behaviour across versions. It detects shape mismatches and replaces placeholder parameters with
+        correctly-shaped tensors before the default `load_state_dict` logic runs.
+        """
+        for key, value in state_dict.items():
+            if not key.startswith(prefix):
+                continue
+            local_key = key[len(prefix) :]
+            parts = local_key.split(".")
+            try:
+                # Use get_submodule for the parent path
+                parent_path = ".".join(parts[:-1])
+                target = self.get_submodule(parent_path) if parent_path else self
+                last = parts[-1]
+                if last.isdigit():
+                    current = target[int(last)]
+                else:
+                    current = getattr(target, last)
+            except (AttributeError, IndexError, KeyError):
+                continue
+
+            if isinstance(current, (torch.Tensor, nn.Parameter)) and current.shape != value.shape:
+                new_param = nn.Parameter(torch.empty_like(value), requires_grad=current.requires_grad)
+                if last.isdigit():
+                    target[int(last)] = new_param
+                else:
+                    setattr(target, last, new_param)
+
+        super()._load_from_state_dict(
+            state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs
+        )
+
+    def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+        """
+        Forward pass with Adamss adaptation.
+        """
+        previous_dtype = x.dtype
+
+        if self._disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            # Adapter weights are already merged into base_layer.weight,
+            # so just call base_layer directly (no adapter delta needed).
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            # Cast input to layer dtype
+            x = x.to(self.dtype)
+
+            # Add bias column only when the base layer has a bias
+            # (update_layer concatenates bias into newB only when bias is not None)
+            if self.get_base_layer().bias is not None:
+                if x.dim() == 2:
+                    ones = torch.ones(x.shape[0], 1, device=x.device, dtype=self.dtype)
+                else:  # x.dim() == 3 or more
+                    ones = torch.ones(*x.shape[:-1], 1, device=x.device, dtype=self.dtype)
+                newx = torch.cat((x, ones), dim=-1)
+            else:
+                newx = x
+
+            # Base output from the frozen original weight
+            result = self.base_layer(x, *args, **kwargs)
+
+            # Iterate over all active adapters and add their deltas
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.adamss_A:
+                    continue
+
+                # Project input into low-rank space
+                projected = F.linear(newx, self.adamss_newB[active_adapter].to(self.dtype))  # (..., r)
+
+                # Apply A and B transformations per subspace
+                # TODO: if all subspaces have equal output dimensions, this loop could
+                # be replaced with a batched matmul/einsum for better performance.
+                # Currently B_i shapes vary per subspace (clustering-dependent), so we loop.
+                subspace_chunks = []
+                for i in range(self.num_subspaces[active_adapter]):
+                    A_i = self.adamss_A[active_adapter][i].to(self.dtype)  # (ri, r)
+                    B_i = self.adamss_B[active_adapter][i].to(self.dtype)  # (seg_len_i, ri)
+                    subspace_out = F.linear(projected, A_i)  # (..., ri)
+                    subspace_out = F.linear(subspace_out, B_i)  # (..., seg_len_i)
+                    subspace_chunks.append(subspace_out)
+
+                # Concatenate subspace results and scatter to output dimension order
+                adapter_delta = torch.cat(subspace_chunks, dim=-1)
+                scatter_index_tensor = self.scatter_index[active_adapter].to(adapter_delta.device)
+
+                if adapter_delta.dim() == 2:
+                    index = scatter_index_tensor.unsqueeze(0).expand(adapter_delta.shape[0], -1)
+                    adapter_delta = torch.zeros(
+                        adapter_delta.shape[0],
+                        result.shape[-1],
+                        device=adapter_delta.device,
+                        dtype=adapter_delta.dtype,
+                    ).scatter(1, index, adapter_delta)
+                else:
+                    index = scatter_index_tensor.unsqueeze(0).unsqueeze(0).expand(*adapter_delta.shape[:-1], -1)
+                    adapter_delta = torch.zeros(
+                        *adapter_delta.shape[:-1],
+                        result.shape[-1],
+                        device=adapter_delta.device,
+                        dtype=adapter_delta.dtype,
+                    ).scatter(-1, index, adapter_delta)
+
+                result = result + adapter_delta
+
+        # Cast back to original dtype
+        return result.to(previous_dtype)
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights.
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. Defaults to `False`.
+            adapter_names (`list[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        for active_adapter in adapter_names:
+            if active_adapter in self.adamss_A:
+                base_layer = self.get_base_layer()
+                if safe_merge:
+                    # Note that safe_merge will be slower than the normal merge
+                    # because of the copy operation.
+                    orig_weight = base_layer.weight.data.clone()
+                    orig_dtype = orig_weight.dtype
+                    delta_weight = self.get_delta_weight(active_adapter)
+                    orig_weight += delta_weight.to(orig_dtype)
+
+                    if not torch.isfinite(orig_weight).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    base_layer.weight.data = orig_weight
+
+                    # Also update bias if present
+                    if base_layer.bias is not None:
+                        orig_bias = base_layer.bias.data.clone()
+                        delta_bias = self.get_delta_bias(active_adapter)
+                        orig_bias += delta_bias.to(orig_dtype)
+                        if not torch.isfinite(orig_bias).all():
+                            raise ValueError(
+                                f"NaNs detected in the merged bias. The adapter {active_adapter} seems to be broken"
+                            )
+                        base_layer.bias.data = orig_bias
+                else:
+                    delta_weight = self.get_delta_weight(active_adapter)
+                    base_layer.weight.data += delta_weight
+
+                    # Also update bias if present
+                    if base_layer.bias is not None:
+                        delta_bias = self.get_delta_bias(active_adapter)
+                        base_layer.bias.data += delta_bias
+
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        """
+        This method unmerges all merged adapter layers from the base weights.
+        """
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self.adamss_A:
+                base_layer = self.get_base_layer()
+                weight = base_layer.weight
+                orig_dtype = weight.dtype
+                delta_weight = self.get_delta_weight(active_adapter)
+                weight.data -= delta_weight.to(orig_dtype)
+
+                # Also update bias if present
+                if base_layer.bias is not None:
+                    delta_bias = self.get_delta_bias(active_adapter)
+                    base_layer.bias.data -= delta_bias.to(orig_dtype)
+
+    def get_delta_weight(self, adapter_name: str) -> torch.Tensor:
+        """
+        Compute the delta weight for the given adapter.
+
+        For AdaMSS, the forward computes:
+            result = newx @ resW.T + scatter(newx @ newB.T @ A.T @ B.T)
+
+        Since resW = original_weight_with_bias, the delta is just the adapter path:
+            delta = scatter(B @ A @ newB)
+
+        We extract the weight portion (excluding bias column) as the delta to add to the base layer's weight.
+
+        Args:
+            adapter_name (str): The name of the adapter for which the delta weight should be computed.
+        """
+        device = self.get_base_layer().weight.device
+        dtype = self.get_base_layer().weight.dtype
+        base_weight = self.get_base_layer().weight
+
+        # Get buffers
+        newB = self.adamss_newB[adapter_name]  # Shape: (r, in_features + 1)
+
+        # Get parameter lists
+        param_list_A = self.adamss_A[adapter_name]
+        param_list_B = self.adamss_B[adapter_name]
+
+        # In case users wants to merge the adapter weights that are in
+        # (b)float16 while being on CPU, we need to cast the weights to float32
+        cast_to_fp32 = device.type == "cpu" and dtype in (torch.float16, torch.bfloat16)
+        compute_dtype = torch.float32 if cast_to_fp32 else dtype
+
+        newB = newB.to(device).to(compute_dtype)
+
+        # Compute the adapter contribution (scattered B @ A @ newB)
+        # delta_weight has shape (out_features, in_features + 1)
+        out_features = base_weight.shape[0]
+        in_features_plus_1 = newB.shape[1]
+
+        # Initialize delta weight for the adapter path only
+        delta_weight = torch.zeros(out_features, in_features_plus_1, device=device, dtype=compute_dtype)
+
+        # Compute the transformation for each subspace
+        # For subspace i: contribution = B_i @ A_i @ newB
+        # where A_i has shape (rank_i, r), B_i has shape (seg_len_i, rank_i)
+        chunks = []
+        for i in range(self.num_subspaces[adapter_name]):
+            A_i = param_list_A[i].to(device).to(compute_dtype)  # Shape: (rank_i, r)
+            B_i = param_list_B[i].to(device).to(compute_dtype)  # Shape: (seg_len_i, rank_i)
+
+            # B_i @ A_i @ newB gives shape (seg_len_i, in_features+1)
+            chunk = B_i @ A_i @ newB
+            chunks.append(chunk)
+
+        # Concatenate chunks and scatter to correct positions
+        if chunks:
+            combined = torch.cat(chunks, dim=0)  # Shape: (total_seg_len, in_features+1)
+            # Use scatter_index for assignment
+            scatter_idx = self.scatter_index[adapter_name].to(delta_weight.device)
+            delta_weight[scatter_idx] = combined
+
+        # Extract just the weight portion
+        if self.get_base_layer().bias is not None:
+            # delta_weight[:, :-1] is the weight delta (exclude bias column)
+            output_tensor = delta_weight[:, :-1]  # Shape: (out_features, in_features)
+        else:
+            # No bias column to strip
+            output_tensor = delta_weight  # Shape: (out_features, in_features)
+
+        if cast_to_fp32:
+            output_tensor = output_tensor.to(dtype=dtype)
+
+        return output_tensor
+
+    def get_delta_bias(self, adapter_name: str) -> torch.Tensor:
+        """
+        Compute the bias delta for the given adapter.
+
+        This is the last column of the adapter path contribution (B @ A @ newB).
+
+        Args:
+            adapter_name (str): The name of the adapter for which the bias delta should be computed.
+        """
+        device = self.get_base_layer().weight.device
+        dtype = self.get_base_layer().weight.dtype
+        base_weight = self.get_base_layer().weight
+
+        # Get buffers
+        newB = self.adamss_newB[adapter_name]  # Shape: (r, in_features + 1)
+
+        # Get parameter lists
+        param_list_A = self.adamss_A[adapter_name]
+        param_list_B = self.adamss_B[adapter_name]
+
+        cast_to_fp32 = device.type == "cpu" and dtype in (torch.float16, torch.bfloat16)
+        compute_dtype = torch.float32 if cast_to_fp32 else dtype
+
+        newB = newB.to(device).to(compute_dtype)
+
+        out_features = base_weight.shape[0]
+        in_features_plus_1 = newB.shape[1]
+
+        # Initialize delta weight for the adapter path only
+        delta_weight = torch.zeros(out_features, in_features_plus_1, device=device, dtype=compute_dtype)
+
+        # Compute the transformation for each subspace
+        chunks = []
+        for i in range(self.num_subspaces[adapter_name]):
+            A_i = param_list_A[i].to(device).to(compute_dtype)
+            B_i = param_list_B[i].to(device).to(compute_dtype)
+            chunk = B_i @ A_i @ newB
+            chunks.append(chunk)
+
+        if chunks:
+            combined = torch.cat(chunks, dim=0)
+            scatter_idx = self.scatter_index[adapter_name].to(delta_weight.device)
+            delta_weight[scatter_idx] = combined
+
+        # Extract the bias portion (last column)
+        if self.get_base_layer().bias is None:
+            # No bias — return zeros
+            output_tensor = torch.zeros(base_weight.shape[0], device=device, dtype=compute_dtype)
+        else:
+            output_tensor = delta_weight[:, -1]  # Shape: (out_features,)
+
+        if cast_to_fp32:
+            output_tensor = output_tensor.to(dtype=dtype)
+
+        return output_tensor
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "adamss." + rep

tasks/tasksmith-c488fc138ba1/environment/source/src/peft/tuners/adamss/model.py

@@ -0,0 +1,279 @@
+# Copyright 2026-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from typing import Optional
+
+import torch
+from torch import nn
+
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer, check_target_module_exists
+from peft.utils import (
+    TRANSFORMERS_MODELS_TO_ADAMSS_TARGET_MODULES_MAPPING,
+)
+
+from .config import AdamssConfig
+from .layer import AdamssLayer, Linear
+
+
+class AdamssModel(BaseTuner):
+    """
+    Creates Adamss (Adaptive Multi-Subspaces) model from a pretrained model.
+
+    The method decomposes weight matrices using SVD and clusters the decomposed space into multiple trainable subspaces
+    for parameter-efficient fine-tuning.
+
+    Args:
+        model (`torch.nn.Module`): The model to be adapted.
+        config (`AdamssConfig`): The configuration of the Adamss model.
+        adapter_name (`str`): The name of the adapter, defaults to `"default"`.
+
+    Returns:
+        `torch.nn.Module`: The Adamss model.
+
+    Example:
+        ```python
+        >>> from transformers import AutoModelForImageClassification
+        >>> from peft import AdamssConfig, get_peft_model
+
+        >>> config = AdamssConfig(
+        ...     r=500,
+        ...     num_subspaces=5,
+        ...     target_modules=["query", "value"],
+        ... )
+
+        >>> model = AutoModelForImageClassification.from_pretrained("google/vit-base-patch16-224")
+        >>> adamss_model = get_peft_model(model, config)
+        ```
+
+    **Attributes**:
+        - **model** ([`~torch.nn.Module`]) -- The model to be adapted.
+        - **peft_config** ([`AdamssConfig`]): The configuration of the Adamss model.
+    """
+
+    prefix: str = "adamss_"
+    tuner_layer_cls = AdamssLayer
+    target_module_mapping = TRANSFORMERS_MODELS_TO_ADAMSS_TARGET_MODULES_MAPPING
+
+    def __init__(
+        self, model, config, adapter_name, low_cpu_mem_usage: bool = False, state_dict: Optional[dict] = None
+    ) -> None:
+        # Initialize ASA tracking before BaseTuner injects adapters so attribute exists.
+        self._asa_total_subspaces = {}
+        super().__init__(model, config, adapter_name, low_cpu_mem_usage=low_cpu_mem_usage, state_dict=state_dict)
+
+    @staticmethod
+    def _check_target_module_exists(adamss_config, key):
+        """Helper to check if target module matches the pattern."""
+        return check_target_module_exists(adamss_config, key)
+
+    def _create_and_replace(
+        self,
+        adamss_config: AdamssConfig,
+        adapter_name: str,
+        target: nn.Module,
+        target_name: str,
+        parent: nn.Module,
+        current_key: str,
+        **optional_kwargs,
+    ):
+        """
+        Create and replace target module with Adamss-adapted module.
+        """
+        if current_key is None:
+            raise ValueError("Current Key shouldn't be `None`")
+
+        # Check if already an Adamss layer
+        if isinstance(target, AdamssLayer):
+            target.update_layer(
+                adapter_name,
+                adamss_config.r,
+                config=adamss_config,
+            )
+            # set_adapter is called inside update_layer, but we need to handle
+            # the case where adapter is not in active_adapters
+            if adapter_name not in self.active_adapters:
+                # Ensure the new adapter is frozen if not active
+                target.set_adapter(self.active_adapters, inference_mode=adamss_config.inference_mode)
+        else:
+            # Create new Adamss layer
+            new_module = self._create_new_module(adamss_config, adapter_name, target, **optional_kwargs)
+            self._record_asa_total_subspaces(adapter_name, adamss_config, new_module)
+            # requires_grad is handled inside _create_new_module via set_adapter
+            self._replace_module(parent, target_name, new_module, target)
+
+    def _record_asa_total_subspaces(self, adapter_name: str, adamss_config: AdamssConfig, module: AdamssLayer) -> None:
+        """Track total subspaces per adapter so the ASA schedule matches adamss_pkg."""
+        if not hasattr(module, "num_subspaces"):
+            return
+        layer_num_subspaces = module.num_subspaces.get(adapter_name, 0)
+        if layer_num_subspaces is None or layer_num_subspaces <= 0:
+            return
+        prev_total = self._asa_total_subspaces.get(adapter_name, 0)
+        self._asa_total_subspaces[adapter_name] = prev_total + layer_num_subspaces
+
+    def _create_new_module(
+        self,
+        adamss_config: AdamssConfig,
+        adapter_name: str,
+        target: nn.Module,
+        **kwargs,
+    ) -> nn.Module:
+        """
+        Create a new Adamss module based on the target module type.
+        """
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        if isinstance(target_base_layer, torch.nn.Linear):
+            new_module = Linear(
+                target,
+                adapter_name,
+                r=adamss_config.r,
+                config=adamss_config,
+                **kwargs,
+            )
+        else:
+            raise TypeError(
+                f"Target module {target} is not supported. Currently, only `torch.nn.Linear` is supported."
+            )
+
+        return new_module
+
+    def update_and_allocate(self, global_step: int) -> None:
+        """
+        Update importance scores and apply ASA masking (if enabled).
+
+        This method should be called in **every** training step after ``loss.backward()`` and before
+        ``optimizer.zero_grad()`` when ASA is enabled. Internally it:
+
+        1. Accumulates importance scores via EMA every step during the warmup period.
+        2. At mask intervals, applies global top-K masking and resets importance.
+
+        This is the single entry point for ASA – using the :class:`AdamssAsaCallback` with HuggingFace ``Trainer``
+        simply delegates to this method. For custom training loops, call this directly instead of the callback.
+
+        Args:
+            global_step (`int`): The current training step.
+
+        Example::
+
+            for step, batch in enumerate(dataloader):
+                loss = model(**batch).loss loss.backward() optimizer.step() model.base_model.update_and_allocate(step)
+                optimizer.zero_grad()
+        """
+        for adapter_name in self.active_adapters:
+            config = self.peft_config[adapter_name]
+            if not config.use_asa:
+                continue
+
+            within_warmup = config.init_warmup <= global_step <= config.final_warmup
+
+            # --- collect ASA layers once ---
+            asa_layers = [
+                m for m in self.model.modules() if isinstance(m, AdamssLayer) and adapter_name in m.exp_avg_ipt_A
+            ]
+            if not asa_layers:
+                continue
+
+            # Step 1: accumulate importance EVERY step during warmup
+            if within_warmup:
+                for module in asa_layers:
+                    module.update_importance(adapter_name, config.asa_importance_beta, config.asa_uncertainty_beta)
+
+            # Step 2: at mask intervals → schedule, global mask, then reset
+            is_mask_interval = global_step % config.mask_interval == 0
+            if within_warmup and is_mask_interval:
+                current_target = self._schedule_threshold(global_step, config)
+                if current_target is not None:
+                    self._global_mask_to_target(current_target, adapter_name, asa_layers)
+
+                # Reset importance AFTER masking for fresh accumulation
+                for module in asa_layers:
+                    module.reset_importance(adapter_name)
+
+    def _schedule_threshold(self, step: int, config) -> Optional[int]:
+        """Calculate current target subspaces based on warmup schedule."""
+        total = self._asa_total_subspaces.get(next(iter(self.active_adapters), "default"), 0)
+        if total == 0:
+            total = self._get_asa_total_subspaces()
+        if total == 0:
+            return None
+
+        if step < config.init_warmup:
+            return None
+        elif step <= config.final_warmup:
+            mul_coeff = 1.0 - (step - config.init_warmup) / (config.final_warmup - config.init_warmup)
+            mul_coeff = max(0.0, min(1.0, mul_coeff))
+            exponent = getattr(config, "asa_schedule_exponent", 3.0)
+            return int(config.asa_target_subspaces + (total - config.asa_target_subspaces) * (mul_coeff**exponent))
+        else:
+            return config.asa_target_subspaces
+
+    def _get_asa_total_subspaces(self) -> int:
+        """Get total number of subspaces from model (sum across all layers)."""
+        total = 0
+        for module in self.model.modules():
+            if isinstance(module, AdamssLayer) and module.num_subspaces:
+                total += next(iter(module.num_subspaces.values()))
+        return total
+
+    def _global_mask_to_target(self, target_subspaces: int, adapter_name: str, asa_layers: list) -> None:
+        """
+        Apply **global** top-K masking across all layers.
+
+        Collects importance scores from every subspace in every layer, ranks them globally, and keeps only the top
+        ``target_subspaces`` active.
+        """
+        # 1. Collect (module, subspace_idx, score) for every subspace
+        subspace_scores: list[tuple] = []
+        for module in asa_layers:
+            n_subspaces = module.num_subspaces.get(adapter_name, 0)
+            ipt_A = module.exp_avg_ipt_A[adapter_name]
+            ipt_B = module.exp_avg_ipt_B[adapter_name]
+            unc_A = module.exp_avg_unc_A[adapter_name]
+            unc_B = module.exp_avg_unc_B[adapter_name]
+
+            for i in range(n_subspaces):
+                if ipt_A[i] is None or ipt_B[i] is None:
+                    continue
+                score = (ipt_A[i] * unc_A[i]).mean() + (ipt_B[i] * unc_B[i]).mean()
+                subspace_scores.append((module, i, score))
+
+        if not subspace_scores:
+            return
+
+        # 2. Compute global threshold via kth-value
+        all_scores = torch.stack([s[2] for s in subspace_scores])
+        if target_subspaces >= len(subspace_scores):
+            threshold = float("-inf")
+        else:
+            threshold = -torch.kthvalue(-all_scores, target_subspaces)[0].item()
+
+        # 3. Apply masking
+        for module, idx, score in subspace_scores:
+            is_active = float(score) > threshold
+            param_A = module.adamss_A[adapter_name]
+            param_B = module.adamss_B[adapter_name]
+            if idx < len(param_A):
+                param_A[idx].requires_grad = is_active
+                if not is_active:
+                    param_A[idx].grad = None
+            if idx < len(param_B):
+                param_B[idx].requires_grad = is_active
+                if not is_active:
+                    param_B[idx].grad = None

tasks/tasksmith-c488fc138ba1/environment/source/src/peft/tuners/adamss/utils.py

@@ -0,0 +1,130 @@
+# Copyright 2026-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import torch
+
+
+def slice_pca(tensor, r, device, dtype=torch.float32, random_seed=0):
+    """
+    Perform slice-wise PCA (SVD) on 4D tensor.
+
+    Args:
+        tensor: 4D tensor of shape (B, C, H, W)
+        r: rank for low-rank approximation
+        device: computation device
+        dtype: data type
+        random_seed: seed for the random projection used by `torch.svd_lowrank`, so the decomposition is
+            deterministic and reproducible across save/load
+
+    Returns:
+        VVT: Right singular vectors (B, C, r, W) UU: Left singular vectors (B, C, H, r)
+    """
+    tensor = tensor.to(device)
+    B, C, H, W = tensor.shape
+
+    # Clamp r to the minimum dimension to avoid SVD errors
+    # SVD rank cannot exceed min(H, W)
+    effective_r = min(r, H, W)
+
+    UU = torch.zeros(B, C, H, effective_r, dtype=dtype, device=device)
+    VVT = torch.zeros(B, C, effective_r, W, dtype=dtype, device=device)
+
+    # torch.svd_lowrank draws a random projection internally, so its result (and hence the downstream
+    # clustering and scatter_index) depends on the RNG state. Seed a forked RNG with the configurable
+    # random_seed so the result is deterministic (torch.svd_lowrank does not accept a generator argument);
+    # fork_rng leaves the global RNG stream untouched.
+    fork_devices = [device] if torch.device(device).type == "cuda" else []
+    with torch.random.fork_rng(devices=fork_devices):
+        torch.manual_seed(random_seed)
+        for i in range(B):
+            for j in range(C):
+                U, _, V = torch.svd_lowrank(tensor[i, j, :, :], q=effective_r, niter=2, M=None)
+                UU[i, j, :, :] = U[:, 0:effective_r]
+                VVT[i, j, :, :] = V[:, 0:effective_r].T
+    # Return computed matrices (important: ensure callers receive VVT and UU)
+    return VVT, UU
+
+
+def clustering_Z(VT, num_subspaces, iternum):
+    """
+    Cluster the rows of VT into K subspaces using K-Means.
+
+    Args:
+        VT: Matrix to cluster (rows are clustered)
+        num_subspaces: Number of clusters (subspaces)
+        iternum: Maximum iterations for K-Means
+
+    Returns:
+        cluster_idx: Cluster assignments as a ``torch.LongTensor`` effective_num_subspaces: Actual number of subspaces
+        used (``int``)
+
+    Note:
+        This function requires scikit-learn to be installed. Install it with: pip install scikit-learn
+    """
+    # Local import with helpful error message
+    try:
+        from sklearn.cluster import KMeans
+    except ImportError:
+        raise ImportError(
+            "scikit-learn is required for AdaMSS initialization. Please install it with: pip install scikit-learn"
+        )
+
+    # Move to numpy for sklearn compatibility
+    # Note: We do NOT normalize row vectors here to match the original adamss_pkg behavior.
+    # Although normalization is generally recommended for cosine-similarity-like clustering,
+    # the reference implementation clusters raw singular vectors.
+    vt = VT.detach().cpu().numpy().astype("float32")
+
+    # Auto-clamp num_subspaces to available samples (output dimensions)
+    # Cannot cluster n samples into more than n clusters
+    effective_num_subspaces = min(num_subspaces, vt.shape[0])
+
+    kmeans = KMeans(
+        n_clusters=effective_num_subspaces, init="random", n_init=1, max_iter=iternum, random_state=123456789
+    )
+    idx = kmeans.fit_predict(vt)
+
+    return torch.from_numpy(idx).long(), effective_num_subspaces
+
+
+def seg_locations(index):
+    """
+    Segment indices into locations based on cluster assignments.
+
+    Args:
+        index: Cluster assignments as a ``torch.LongTensor``
+
+    Returns:
+        location: Dict mapping cluster id to ``torch.LongTensor`` of row indices.
+            Clusters are ordered by their smallest index so that KMeans label permutations do not affect downstream
+            ordering.
+    """
+    K = int(index.max().item()) + 1
+    location = {}
+    for i in range(K):
+        location[i] = torch.where(index == i)[0]
+    return location
+
+
+def get_trainable_subspaces(num_subspaces):
+    """
+    Get all trainable subspace indices.
+
+    Args:
+        num_subspaces: Number of subspaces
+
+    Returns:
+        List of trainable subspace indices (``list[int]``)
+    """
+    return list(range(num_subspaces))

tasks/tasksmith-c488fc138ba1/environment/source/src/peft/tuners/adaption_prompt/__init__.py

@@ -0,0 +1,23 @@
+# Copyright 2023-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from peft.utils import register_peft_method
+
+from .config import AdaptionPromptConfig
+from .layer import AdaptedAttention
+from .model import AdaptionPromptModel
+
+
+__all__ = ["AdaptedAttention", "AdaptionPromptConfig", "AdaptionPromptModel"]
+
+register_peft_method(name="adaption_prompt", config_cls=AdaptionPromptConfig, model_cls=AdaptionPromptModel)

tasks/tasksmith-c488fc138ba1/environment/source/src/peft/tuners/adaption_prompt/config.py

@@ -0,0 +1,88 @@
+# Copyright 2023-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from collections import namedtuple
+from dataclasses import dataclass, field
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+from .utils import gpt2_compute_query_states, llama_compute_query_states
+
+
+@dataclass
+class AdaptionPromptConfig(PeftConfig):
+    """Stores the configuration of an [`AdaptionPromptModel`]."""
+
+    target_modules: str = field(
+        default=None, metadata={"help": "Name of the attention submodules to insert adaption prompts into."}
+    )
+    adapter_len: int = field(default=None, metadata={"help": "Number of adapter tokens to insert"})
+    adapter_layers: int = field(default=None, metadata={"help": "Number of adapter layers (from the top)"})
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.ADAPTION_PROMPT
+
+    @property
+    def is_adaption_prompt(self) -> bool:
+        """Return True if this is an adaption prompt config."""
+        return True
+
+
+# Contains the config that is specific to a transformers model type.
+ModelTypeConfig = namedtuple(
+    "ModelTypeConfig", ["compute_query_states", "target_modules", "k_proj_layer", "v_proj_layer", "o_proj_layer"]
+)
+
+# Mapping of transformers model types to their specific configuration.
+TRANSFORMERS_MODEL_CONFIG = {
+    "llama": ModelTypeConfig(
+        compute_query_states=llama_compute_query_states,
+        target_modules="self_attn",
+        k_proj_layer="k_proj",
+        v_proj_layer="v_proj",
+        o_proj_layer="o_proj",
+    ),
+    "mistral": ModelTypeConfig(  # same as llama,
+        compute_query_states=llama_compute_query_states,
+        target_modules="self_attn",
+        k_proj_layer="k_proj",
+        v_proj_layer="v_proj",
+        o_proj_layer="o_proj",
+    ),
+    "gpt2": ModelTypeConfig(  # piggybacking of off the prior definitions, GPTs attention calculation is different
+        compute_query_states=gpt2_compute_query_states,
+        target_modules="attn",
+        k_proj_layer="c_attn",
+        v_proj_layer=None,
+        o_proj_layer=None,
+    ),
+}
+
+
+def prepare_config(
+    peft_config: AdaptionPromptConfig,
+    model,
+) -> AdaptionPromptConfig:
+    """Prepare the config based on the llama model type."""
+    if model.config.model_type not in TRANSFORMERS_MODEL_CONFIG:
+        raise ValueError(f"Unsupported model type for adaption prompt: '{model.config.model_type}'.")
+
+    model_config = TRANSFORMERS_MODEL_CONFIG[model.config.model_type]
+
+    if peft_config.target_modules is None:
+        peft_config.target_modules = model_config.target_modules
+
+    return peft_config

tasks/tasksmith-c488fc138ba1/environment/source/src/peft/tuners/adaption_prompt/layer.py

@@ -0,0 +1,223 @@
+# Copyright 2023-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import math
+from typing import Optional, Union
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+from .config import TRANSFORMERS_MODEL_CONFIG
+
+
+class _BaseAdaptedAttention(nn.Module):
+    """Base module, which defines adaption prompts for multiple model types."""
+
+    def __init__(self, model_type: str, adapter_len: int, model, target_dtype=torch.float32):
+        """
+        Initialize object.
+
+        Args:
+            model_type: The transformer model type. This is used to retrieve the right method to
+                compute query states.
+            adapter_len: The length of the adaption prompt to insert.
+            model: The original transformer attention module that is being wrapped.
+        """
+        if isinstance(model, _BaseAdaptedAttention):
+            raise TypeError("Unable to stack multiple adaption prompts")
+        super().__init__()
+        self.model_type = model_type
+        self.model = model
+        self.adapter_len = adapter_len
+        # Assume all parameters of the attention model we are wrapping are on the same device.
+
+        device = next(model.parameters()).device
+        # Don't think this was specified in the paper, but we follow the official repo which used an Embedding
+        # which initializes the tokens with standard normal values.
+        # https://github.com/ZrrSkywalker/LLaMA-Adapter/blob/41c3546fe1997ab8a65809dc8d8f9252b19d9faf/llama/model.py#L234
+        # (bsz, adapter_len, hidden_size)
+
+        hidden_size = self.model.config.hidden_size
+        self.num_heads = self.model.config.num_attention_heads
+
+        self.adaption_prompt = nn.Parameter(
+            torch.empty(1, adapter_len, hidden_size, device=device, dtype=target_dtype).normal_()
+        )
+        # Initialize the gate to 0 as this is "zero-init".
+        self.adaption_gate = nn.Parameter(torch.zeros(1, device=device, dtype=target_dtype))
+
+
+class AdaptedAttentionGPT(_BaseAdaptedAttention):
+    """This module wraps a GPT2Attention module and injects adaption prompts"""
+
+    def __init__(self, model_type, adapter_len, model):
+        target_dtype = (
+            model.c_proj.weight.dtype if model.c_proj.weight.dtype not in [torch.int8, torch.uint8] else torch.float32
+        )
+        super().__init__(model_type, adapter_len, model, target_dtype=target_dtype)
+
+    def forward(
+        self,
+        hidden_states: Optional[tuple[torch.FloatTensor]],
+        layer_past: Optional[tuple[torch.Tensor]] = None,
+        attention_mask: Optional[torch.FloatTensor] = None,
+        head_mask: Optional[torch.FloatTensor] = None,
+        encoder_hidden_states: Optional[torch.Tensor] = None,
+        encoder_attention_mask: Optional[torch.FloatTensor] = None,
+        use_cache: Optional[bool] = False,
+        output_attentions: Optional[bool] = False,
+        **kwargs,
+    ) -> tuple[Union[torch.Tensor, tuple[torch.Tensor]], ...]:
+        attn_outputs = self.model(
+            hidden_states=hidden_states,
+            attention_mask=attention_mask,
+            head_mask=head_mask,
+            encoder_hidden_states=encoder_hidden_states,
+            encoder_attention_mask=encoder_attention_mask,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            **kwargs,
+        )
+        """
+        Forward pass for the adapter which wraps the GPT2Attention module
+        """
+
+        attn_output = attn_outputs[0]
+        add_outputs = attn_outputs[1:]
+
+        c_attn_layer = TRANSFORMERS_MODEL_CONFIG[self.model_type].k_proj_layer
+
+        bsz = attn_output.shape[0]
+        q_len = attn_output.shape[1]
+        embed_dim = attn_output.shape[2]
+
+        _, key, value = getattr(self.model, c_attn_layer)(self.adaption_prompt).split(embed_dim, dim=2)
+
+        adapter_k = (
+            key.view(1, self.adapter_len, self.num_heads, self.model.head_dim).repeat(bsz, 1, 1, 1).transpose(1, 2)
+        )
+        adapter_v = (
+            value.view(1, self.adapter_len, self.num_heads, self.model.head_dim).repeat(bsz, 1, 1, 1).transpose(1, 2)
+        )
+        # recompute query state since it is not returned by GPT2 forward
+        compute_query_states = TRANSFORMERS_MODEL_CONFIG[self.model_type].compute_query_states
+        query_states = compute_query_states(
+            self.model, hidden_states=hidden_states, encoder_hidden_states=encoder_hidden_states
+        )
+
+        previous_dtype = query_states.dtype
+
+        scores = torch.matmul(query_states, adapter_k.transpose(2, 3).to(previous_dtype)) / math.sqrt(
+            self.model.head_dim
+        )
+        # Upcast attention to fp32
+        # (bsz, num_heads, q_len, adapter_len)
+        scores = self.adaption_gate * F.softmax(scores, dim=-1, dtype=torch.float32).to(previous_dtype)
+        # (bsz, q_len, num_heads * head_dim)
+        adapter_output = torch.matmul(scores, adapter_v).transpose(1, 2).reshape(bsz, q_len, -1)
+
+        # Add adaption prompt output to original output.
+        hidden_state = attn_output + adapter_output
+
+        # Restore original dtype.
+        hidden_state = hidden_state.to(previous_dtype)
+
+        # add additional attention outputs (attention and cross attention)
+        output = (hidden_state,) + add_outputs
+        return output
+
+
+class AdaptedAttention(_BaseAdaptedAttention):
+    """This module wraps a LLamaAttention module and injects adaption prompts."""
+
+    def __init__(self, model_type, adapter_len, model):
+        target_dtype = (
+            model.q_proj.weight.dtype if model.q_proj.weight.dtype not in [torch.int8, torch.uint8] else torch.float32
+        )
+        super().__init__(model_type, adapter_len, model, target_dtype=target_dtype)
+
+    def forward(self, **kwargs):
+        """
+        Forward pass for the adapter which wraps the original LlamaAttention module.
+
+        "Official" paper implementation:
+        https://github.com/ZrrSkywalker/LLaMA-Adapter/blob/41c3546fe1997ab8a65809dc8d8f9252b19d9faf/llama/model.py#L141
+
+        Args:
+            kwargs: See the original LlamaAttention module.
+        """
+        if kwargs.get("output_attention", False):
+            raise NotImplementedError("output_attention is not currently supported.")
+
+        output, *_ = self.model(**kwargs)
+        bsz = output.shape[0]
+        q_len = output.shape[1]
+        embed_dim = output.shape[2]
+        k_proj_layer = TRANSFORMERS_MODEL_CONFIG[self.model_type].k_proj_layer
+        v_proj_layer = TRANSFORMERS_MODEL_CONFIG[self.model_type].v_proj_layer
+        o_proj_layer = TRANSFORMERS_MODEL_CONFIG[self.model_type].o_proj_layer
+        factor = (
+            self.model.k_proj.in_features // self.model.k_proj.out_features
+        )  # Mistral has different input and output dimension for k_proj and v_proj layers
+
+        if k_proj_layer == v_proj_layer:
+            _, key, value = getattr(self.model, k_proj_layer)(self.adaption_prompt).split(embed_dim, dim=2)
+        else:
+            key = getattr(self.model, k_proj_layer)(self.adaption_prompt)
+            value = getattr(self.model, v_proj_layer)(self.adaption_prompt)
+
+        num_heads = self.model.config.num_attention_heads
+        # (bsz, num_key_value_heads, adapter_len, head_dim)
+        adapter_k = (
+            key.view(1, self.adapter_len, (num_heads // factor), self.model.head_dim)
+            .repeat(bsz, 1, 1, 1)
+            .transpose(1, 2)
+        )
+        adapter_v = (
+            value.view(1, self.adapter_len, (num_heads // factor), self.model.head_dim)
+            .repeat(bsz, 1, 1, 1)
+            .transpose(1, 2)
+        )
+        # Below is taken from https://github.com/huggingface/transformers/blob/e547458c43dfdbbb8f6a7757237e234c44e20a8f/src/transformers/models/mistral/modeling_mistral.py#L181
+        # (bsz, num_heads, adapter_len, head_dim)
+        adapter_k = torch.repeat_interleave(adapter_k, repeats=factor, dim=1)
+        adapter_v = torch.repeat_interleave(adapter_v, repeats=factor, dim=1)
+        # Recompute query states.
+        compute_query_states = TRANSFORMERS_MODEL_CONFIG[self.model_type].compute_query_states
+        # (bsz, num_heads, q_len, head_dim)
+        query_states = compute_query_states(model=self.model, **kwargs)
+
+        previous_dtype = query_states.dtype
+
+        # (bsz, num_heads, q_len, adapter_len)
+        scores = torch.matmul(query_states, adapter_k.transpose(2, 3).to(previous_dtype)) / math.sqrt(
+            self.model.head_dim
+        )
+        # Upcast attention to fp32
+        # (bsz, num_heads, q_len, adapter_len)
+        scores = self.adaption_gate * F.softmax(scores, dim=-1, dtype=torch.float32).to(previous_dtype)
+        # (bsz, q_len, num_heads * head_dim)
+        adapter_output = torch.matmul(scores, adapter_v).transpose(1, 2).reshape(bsz, q_len, -1)
+
+        # (bsz, q_len, hidden_size)
+        if o_proj_layer is not None:
+            adapter_output = getattr(self.model, o_proj_layer)(adapter_output)
+
+        # Add adaption prompt output to original output.
+        output = output + adapter_output
+
+        # Restore original dtype.
+        output = output.to(previous_dtype)
+        return output, *_