Stage Harbor release files 53001-53500

tasks/tasksmith-749ff8d440e1/environment/source/method_comparison/text_generation_benchmark/utils.py

@@ -0,0 +1,458 @@
+# 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.
+
+"""
+Utilities for PEFT benchmarking.
+"""
+
+import datetime
+import json
+import os
+import platform
+import subprocess
+from collections.abc import Callable
+from dataclasses import asdict, dataclass, field
+from enum import Enum
+from typing import Any, Optional
+
+import psutil
+import torch
+
+from peft.utils import infer_device
+
+
+FILE_NAME_BENCHMARK_PARAMS = "benchmark_params.json"
+FILE_NAME_DEFAULT_CONFIG = "default_benchmark_params.json"
+
+RESULT_PATH = os.path.join(os.path.dirname(__file__), "results")
+RESULT_PATH_TEMP = os.path.join(os.path.dirname(__file__), "temporary_results")
+RESULT_PATH_CANCELLED = os.path.join(os.path.dirname(__file__), "cancelled_results")
+
+
+class BenchmarkStatus(Enum):
+    """Status of a benchmark run."""
+
+    SUCCESS = "success"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+    RUNNING = "running"
+
+
+@dataclass
+class BenchmarkResult:
+    """Container for benchmark results."""
+
+    experiment_name: str
+    status: BenchmarkStatus
+
+    model_id: str
+
+    run_info: dict = field(default_factory=dict)
+    generation_info: dict = field(default_factory=dict)
+    meta_info: dict = field(default_factory=dict)
+
+    def __post_init__(self):
+        """Initialize structured data format."""
+        device = infer_device()
+        torch_accelerator_module = getattr(torch, device, torch.cuda)
+        self.run_info = {
+            "timestamp": datetime.datetime.now(tz=datetime.timezone.utc).isoformat(),
+            "duration": 0.0,
+            "status": self.status.value,
+            "hardware": {
+                "num_accelerators": torch_accelerator_module.device_count() if torch_accelerator_module.is_available() else 0,
+                "accelerator_type": torch_accelerator_module.get_device_name(0) if torch_accelerator_module.is_available() else "N/A",
+                "cuda_version": torch.version.cuda if torch.cuda.is_available() else "N/A",
+                "pytorch_version": torch.__version__,
+            },
+        }
+
+        self.meta_info = {
+            "model_id": self.model_id,
+            "parameters": {
+                "base_params": 0,
+                "trainable_params": 0,
+                "total_params": 0,
+                "param_ratio": 0.0,
+            },
+            "model_size": {
+                "base_model_size_mb": 0.0,
+                "adapter_size_mb": 0.0,
+            },
+            "package_info": {
+                "transformers-version": None,
+                "transformers-commit-hash": None,
+                "peft-version": None,
+                "peft-commit-hash": None,
+                "datasets-version": None,
+                "datasets-commit-hash": None,
+                "bitsandbytes-version": None,
+                "bitsandbytes-commit-hash": None,
+                "torch-version": torch.__version__,
+                "torch-commit-hash": None,
+            },
+            "system_info": {
+                "system": platform.system(),
+                "release": platform.release(),
+                "version": platform.version(),
+                "machine": platform.machine(),
+                "processor": platform.processor(),
+                "accelerator": torch_accelerator_module.get_device_name(0) if torch_accelerator_module.is_available() else "N/A",
+            },
+        }
+
+        self.generation_info = {
+            "memory": {
+                "peak_accelerator_memory_mb": 0.0,
+                "peak_ram_memory_mb": 0.0,
+                "memory_logs": [],
+            },
+            "by_category": {},
+            "overall": {},
+        }
+
+    def update_meta_info(self, param_counts: dict, size_info: dict, package_info: Optional[dict] = None):
+        """Update model metadata information."""
+        self.meta_info["parameters"].update(param_counts)
+        self.meta_info["model_size"].update(size_info)
+        if package_info:
+            self.meta_info["package_info"].update(package_info)
+
+    def update_generation_info(self, memory_data: Optional[dict] = None, performance_metrics: Optional[dict] = None):
+        """Update generation performance information, primarily for memory and high-level performance."""
+        if memory_data:
+            self.generation_info["memory"].update(memory_data)
+        if performance_metrics:  # For things like overall tokens/sec if calculated
+            self.generation_info.update(performance_metrics)
+
+    def add_memory_log(self, stage: str, ram_mb: float, accelerator_allocated_mb: float, accelerator_reserved_mb: float):
+        """Add a memory usage log entry to generation_info."""
+        self.generation_info["memory"]["memory_logs"].append(
+            {
+                "stage": stage,
+                "ram_mb": ram_mb,
+                "accelerator_allocated_mb": accelerator_allocated_mb,
+                "accelerator_reserved_mb": accelerator_reserved_mb,
+            }
+        )
+
+    def add_metrics_for_category(self, category: str, metrics: dict, individual_samples: Optional[list] = None):
+        """Add metrics for a specific prompt category under generation_info."""
+        category_data = {"metrics": metrics, "samples": individual_samples if individual_samples is not None else []}
+        self.generation_info["by_category"][category] = category_data
+
+    def update_run_info(
+        self,
+        duration: float,
+        status: BenchmarkStatus,
+        error: Optional[str] = None,
+        peft_config: Optional[dict] = None,
+        benchmark_config: Optional[dict] = None,
+    ):
+        """Update run information."""
+        self.run_info["duration"] = duration
+        self.run_info["status"] = status.value
+        if error:
+            self.run_info["error"] = error
+        if peft_config:
+            self.run_info["peft_config"] = peft_config
+        if benchmark_config:
+            self.run_info["benchmark_config"] = benchmark_config
+
+    def compute_overall_metrics(self):
+        """Compute overall metrics across all categories within generation_info."""
+        if not self.generation_info["by_category"]:
+            return
+
+        categories = self.generation_info["by_category"]
+        key_metrics = [
+            "inference_time",
+            "base_inference_time",
+            "inference_overhead_pct",
+            "time_per_token",
+            "generated_tokens",
+        ]
+
+        for metric in key_metrics:
+            values = []
+            for category_data in categories.values():
+                if "metrics" in category_data and metric in category_data["metrics"]:
+                    values.append(category_data["metrics"][metric])
+
+            if values:
+                self.generation_info["overall"][metric] = sum(values) / len(values)
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert result to dictionary."""
+        self.compute_overall_metrics()
+        return {
+            "run_info": self.run_info,
+            "generation_info": self.generation_info,
+            "meta_info": self.meta_info,
+        }
+
+    def save(self, path: Optional[str] = None):
+        """Save result to JSON file."""
+        if path is None:
+            peft_branch = get_peft_branch()
+        if self.status == BenchmarkStatus.CANCELLED:
+            base_path = RESULT_PATH_CANCELLED
+        elif peft_branch != "main":
+            base_path = RESULT_PATH_TEMP
+        elif self.status == BenchmarkStatus.SUCCESS:
+            base_path = RESULT_PATH
+        elif self.status == BenchmarkStatus.FAILED:
+            base_path = RESULT_PATH_CANCELLED
+        else:
+            base_path = RESULT_PATH_TEMP
+
+        filename = f"{self.experiment_name}.json"
+        path = os.path.join(base_path, filename)
+
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+
+        with open(path, "w") as f:
+            json.dump(self.to_dict(), f, indent=2)
+
+        return path
+
+
+@dataclass
+class BenchmarkConfig:
+    """Configuration for benchmarking PEFT methods."""
+
+    model_id: str
+
+    seed: int
+    num_inference_runs: int
+    max_new_tokens: int
+
+    dtype: str = "float16"
+    use_4bit: bool = False
+    use_8bit: bool = False
+
+    category_generation_params: Optional[dict] = None
+
+    def __post_init__(self) -> None:
+        """Validate configuration."""
+        if not isinstance(self.model_id, str):
+            raise TypeError(f"Invalid model_id: {self.model_id}")
+
+        if self.seed < 0:
+            raise ValueError(f"Invalid seed: {self.seed}")
+
+        if self.num_inference_runs <= 0:
+            raise ValueError(f"Invalid num_inference_runs: {self.num_inference_runs}")
+
+        if self.max_new_tokens <= 0:
+            raise ValueError(f"Invalid max_new_tokens: {self.max_new_tokens}")
+
+    @classmethod
+    def from_dict(cls, config_dict: dict) -> "BenchmarkConfig":
+        """Create config from dictionary."""
+        valid_keys = set(cls.__dataclass_fields__.keys())
+        filtered_dict = {k: v for k, v in config_dict.items() if k in valid_keys}
+
+        return cls(**filtered_dict)
+
+    @classmethod
+    def from_json(cls, json_path: str) -> "BenchmarkConfig":
+        """Load config from JSON file."""
+        with open(json_path) as f:
+            config_dict = json.load(f)
+        return cls.from_dict(config_dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert config to dictionary."""
+        result = asdict(self)
+        return result
+
+    def save(self, path: str) -> None:
+        """Save config to JSON file."""
+        with open(path, "w") as f:
+            json.dump(self.to_dict(), f, indent=2)
+
+    def merge_from_dict(self, config_dict: dict) -> None:
+        """Merge settings from a dictionary into this config object.
+        Keys in config_dict will override existing attributes.
+        """
+        for key, value in config_dict.items():
+            if hasattr(self, key):
+                setattr(self, key, value)
+
+
+def validate_experiment_path(path: str) -> tuple[str, "BenchmarkConfig"]:
+    """Validate experiment path, load and merge configs, and return them."""
+    if not os.path.exists(path):
+        raise FileNotFoundError(f"Experiment path not found: {path}")
+
+    path_parts = os.path.normpath(path).split(os.sep)
+
+    try:
+        experiments_idx = path_parts.index("experiments")
+    except ValueError:
+        experiment_name = os.path.basename(path.rstrip(os.sep))
+    else:
+        if experiments_idx + 1 < len(path_parts):
+            method_name = path_parts[experiments_idx + 1]
+            remaining_parts = path_parts[experiments_idx + 2 :]
+            if remaining_parts:
+                remaining_name = "-".join(remaining_parts)
+                experiment_name = f"{method_name}--{remaining_name}"
+            else:
+                experiment_name = method_name
+        else:
+            experiment_name = os.path.basename(path.rstrip(os.sep))
+
+    default_config_path = os.path.join(os.path.dirname(__file__), FILE_NAME_DEFAULT_CONFIG)
+    experiment_benchmark_params_path = os.path.join(path, FILE_NAME_BENCHMARK_PARAMS)
+
+    if not os.path.exists(default_config_path):
+        raise FileNotFoundError(f"Default configuration file not found: {default_config_path}. This is required.")
+    benchmark_config = BenchmarkConfig.from_json(default_config_path)
+    print(f"Loaded default configuration from {default_config_path}")
+
+    if os.path.exists(experiment_benchmark_params_path):
+        with open(experiment_benchmark_params_path) as f:
+            experiment_specific_params = json.load(f)
+
+        benchmark_config.merge_from_dict(experiment_specific_params)
+        print(f"Loaded and merged experiment-specific parameters from {experiment_benchmark_params_path}")
+    else:
+        print(f"No {FILE_NAME_BENCHMARK_PARAMS} found in {path}. Using only default configuration.")
+
+    return experiment_name, benchmark_config
+
+
+def get_memory_usage() -> tuple[float, float, float]:
+    """Get current memory usage (RAM and accelerator)."""
+    process = psutil.Process(os.getpid())
+    ram_usage_bytes = process.memory_info().rss
+    ram_usage_mb = ram_usage_bytes / (1024 * 1024)
+
+    if torch.cuda.is_available():
+        accelerator_allocated = torch.cuda.memory_allocated()
+        accelerator_reserved = torch.cuda.memory_reserved()
+        accelerator_allocated_mb = accelerator_allocated / (1024 * 1024)
+        accelerator_reserved_mb = accelerator_reserved / (1024 * 1024)
+    elif torch.xpu.is_available():
+        accelerator_allocated = torch.xpu.memory_allocated()
+        accelerator_reserved = torch.xpu.memory_reserved()
+        accelerator_allocated_mb = accelerator_allocated / (1024 * 1024)
+        accelerator_reserved_mb = accelerator_reserved / (1024 * 1024)
+    else:
+        accelerator_allocated_mb = 0.0
+        accelerator_reserved_mb = 0.0
+
+    return ram_usage_mb, accelerator_allocated_mb, accelerator_reserved_mb
+
+
+def init_accelerator() -> tuple[float, float]:
+    """Initialize accelerator and return initial memory usage."""
+    if torch.cuda.is_available():
+        torch.cuda.init()
+        torch.cuda.empty_cache()
+        _, accelerator_allocated, accelerator_reserved = get_memory_usage()
+    elif torch.xpu.is_available():
+        torch.xpu.init()
+        torch.xpu.empty_cache()
+        _, accelerator_allocated, accelerator_reserved = get_memory_usage()
+    else:
+        accelerator_allocated = 0.0
+        accelerator_reserved = 0.0
+    return accelerator_allocated, accelerator_reserved
+
+
+def get_model_size_mb(model: torch.nn.Module, dtype_bytes: int = 4) -> float:
+    """Calculate model size in MB."""
+    return sum(p.numel() * dtype_bytes for p in model.parameters()) / (1024 * 1024)
+
+
+def get_peft_branch() -> str:
+    repo_root = os.path.dirname(__file__)
+    return subprocess.check_output(["git", "rev-parse", "--abbrev-ref", "HEAD"], cwd=repo_root).decode().strip()
+
+
+def log_results(
+    experiment_name: str,
+    benchmark_result: BenchmarkResult,
+    print_fn: Callable = print,
+) -> None:
+    """Log benchmark results to console."""
+    print_fn("\n" + "=" * 50)
+    print_fn(f"Benchmark Results: {experiment_name}")
+    print_fn("=" * 50)
+
+    print_fn(f"Status: {benchmark_result.run_info.get('status', 'N/A')}")
+    print_fn(f"Duration: {benchmark_result.run_info.get('duration', 0):.2f} seconds")
+
+    if benchmark_result.run_info.get("status") != BenchmarkStatus.SUCCESS.value:
+        print_fn(f"Error: {benchmark_result.run_info.get('error', 'Unknown error')}")
+        print_fn("=" * 50)
+        return
+
+    print_fn("\nModel Information:")
+    print_fn(f"  Base Model: {benchmark_result.meta_info.get('model_id', 'N/A')}")
+
+    print_fn("\nParameter Counts:")
+    params = benchmark_result.meta_info.get("parameters", {})
+    print_fn(f"  Base Parameters: {params.get('base_params', 0):,}")
+    print_fn(f"  Trainable Parameters: {params.get('trainable_params', 0):,}")
+    print_fn(f"  Parameter Ratio: {params.get('param_ratio', 0):.5%}")
+
+    print_fn("\nModel Size:")
+    size_info = benchmark_result.meta_info.get("model_size", {})
+    print_fn(f"  Base Model: {size_info.get('base_model_size_mb', 0):.2f} MB")
+    print_fn(f"  Adapter: {size_info.get('adapter_size_mb', 0):.2f} MB")
+
+    print_fn("\nMemory Usage (from generation_info):")
+    memory_data = benchmark_result.generation_info.get("memory", {})
+    print_fn(f"  Peak Accelerator Memory: {memory_data.get('peak_accelerator_memory_mb', 0):.2f} MB")
+    print_fn(f"  Peak RAM Memory: {memory_data.get('peak_ram_memory_mb', 0):.2f} MB")
+
+    print_fn("\nDetailed Metrics (from generation_info.by_category):")
+    if benchmark_result.generation_info.get("by_category"):
+        for category, cat_data in benchmark_result.generation_info["by_category"].items():
+            print_fn(f"  Category: {category}")
+            metrics = cat_data.get("metrics", {})
+            print_fn(f"    Inference Time: {metrics.get('inference_time', 0):.4f} seconds")
+            print_fn(f"    Base Inference Time: {metrics.get('base_inference_time', 0):.4f} seconds")
+            print_fn(f"    Inference Overhead: {metrics.get('inference_overhead_pct', 0):.2f}%")
+            print_fn(f"    Time Per Token: {metrics.get('time_per_token', 0):.6f} seconds/token")
+            print_fn(f"    Generated Tokens: {metrics.get('generated_tokens', 0):.1f}")
+
+            samples = cat_data.get("samples", [])
+            if samples:
+                print_fn(f"    Number of Samples: {len(samples)}")
+                print_fn(
+                    f"    Average Generated Tokens: {sum(s.get('generated_tokens', 0) for s in samples) / len(samples):.1f}"
+                )
+    else:
+        print_fn("  No per-category metrics available.")
+
+    benchmark_result.compute_overall_metrics()
+
+    print_fn("\nOverall Metrics (from generation_info.overall):")
+    overall = benchmark_result.generation_info.get("overall")
+    if overall:
+        print_fn(f"    Inference Time: {overall.get('inference_time', 0):.4f} seconds")
+        print_fn(f"    Base Inference Time: {overall.get('base_inference_time', 0):.4f} seconds")
+        print_fn(f"    Inference Overhead: {overall.get('inference_overhead_pct', 0):.2f}%")
+        print_fn(f"    Time Per Token: {overall.get('time_per_token', 0):.6f} seconds/token")
+        print_fn(f"    Generated Tokens: {overall.get('generated_tokens', 0):.1f}")
+    else:
+        print_fn("  No overall metrics computed.")
+
+    print_fn("\nSaved results to:", benchmark_result.save())
+    print_fn("=" * 50)

tasks/tasksmith-749ff8d440e1/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-749ff8d440e1/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-749ff8d440e1/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-749ff8d440e1/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-749ff8d440e1/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-749ff8d440e1/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-749ff8d440e1/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-749ff8d440e1/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-749ff8d440e1/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-749ff8d440e1/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-749ff8d440e1/environment/source/src/peft/__init__.py

@@ -0,0 +1,306 @@
+# 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,
+    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",
+    "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-749ff8d440e1/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-749ff8d440e1/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-749ff8d440e1/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-749ff8d440e1/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-749ff8d440e1/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-749ff8d440e1/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-749ff8d440e1/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-749ff8d440e1/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-749ff8d440e1/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-749ff8d440e1/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-749ff8d440e1/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-749ff8d440e1/environment/source/src/peft/tuners/__init__.py

@@ -0,0 +1,171 @@
+# 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 .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",
+    "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-749ff8d440e1/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-749ff8d440e1/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-749ff8d440e1/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-749ff8d440e1/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-749ff8d440e1/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-749ff8d440e1/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-749ff8d440e1/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-749ff8d440e1/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-749ff8d440e1/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-749ff8d440e1/environment/source/src/peft/tuners/adamss/config.py

@@ -0,0 +1,340 @@
+# 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)."
+            )
+        },
+    )
+
+    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-749ff8d440e1/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)
+        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-749ff8d440e1/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-749ff8d440e1/environment/source/src/peft/tuners/adamss/utils.py

@@ -0,0 +1,121 @@
+# 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):
+    """
+    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
+
+    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)
+
+    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-749ff8d440e1/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-749ff8d440e1/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-749ff8d440e1/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, *_

tasks/tasksmith-749ff8d440e1/environment/source/src/peft/tuners/adaption_prompt/model.py

@@ -0,0 +1,171 @@
+# 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 torch import nn
+
+from peft.utils import _freeze_adapter, _get_submodules
+
+from .config import AdaptionPromptConfig, prepare_config
+from .layer import AdaptedAttention, AdaptedAttentionGPT
+from .utils import is_adaption_prompt_trainable
+
+
+class AdaptionPromptModel(nn.Module):
+    """
+    Implements adaption prompts as described in https://huggingface.co/papers/2303.16199.
+
+    The top L attention modules are replaced with AdaptedAttention modules that wrap the original ones, but insert
+    trainable prompts with gates (for zero init).
+
+    Notes on the multi-adapter pattern:
+    - We store the states of different adapters by keeping a dictionary of AdaptedAttention modules indexed by adapter
+      name.
+    - Every time we switch adapters, we remove the modules of the currently active adapter from the model, store them
+      in the dictionary, and replace them with the modules of the new adapter.
+    - To avoid duplicated and potentially inconsistent state, the currently active adapter is always removed from the
+      dictionary.
+    - Disabling the adapter would also result in the modules being removed from the model.
+    """
+
+    def __init__(self, model, configs: dict, adapter_name: str):
+        super().__init__()
+        self.model = model
+        # Store adapter configs by name.
+        self.peft_config: dict[str, AdaptionPromptConfig] = {}
+        # Store lists of the parents of the affected attention modules by adapter name.
+        # We keep references to the parents so we can swap the adapters in-and-out of the model.
+        self._parents: dict[str, list[nn.Module]] = {}
+        # Store lists of cached AdaptedAttention modules by name.
+        self._cached_adapters: dict[str, list] = {}
+        # The name of the currently active adapter.
+        self._active_adapter = None
+        # Whether the adapter is enabled.
+        self._enabled = True
+        self.forward = self.model.forward
+        self.add_adapter(adapter_name, configs[adapter_name])
+        self._mark_only_adaption_prompts_as_trainable(self.model)
+
+    def add_adapter(self, adapter_name: str, config: AdaptionPromptConfig) -> None:
+        """Add an adapter with the given name and config."""
+        config = prepare_config(config, self.model)
+        if adapter_name in self.peft_config:
+            raise ValueError(f"Adapter with name '{adapter_name}' already exists.")
+
+        parents = []
+        for name, _ in self.model.named_modules():
+            if name.endswith(f".{config.target_modules}"):
+                par, _, _ = _get_submodules(self.model, name)
+                parents.append(par)
+        if len(parents) < config.adapter_layers:
+            raise ValueError(
+                f"Config specifies more adapter layers '{config.adapter_layers}' than the model has '{len(parents)}'."
+            )
+        # Note that if the target modules are not in Sequential, ModuleList, or
+        # some other PyTorch ordered container, the behavior is undefined as we
+        # assume here that the order of the modules is the same as the order of
+        # the transformer decoder layers.
+        parents = parents[-config.adapter_layers :]
+        self._parents[adapter_name] = parents
+
+        # It is only None during initialization.
+        # If it is disabled, we don't have to remove the modules.
+        if self._active_adapter is not None and self._enabled:
+            self._remove_adapted_attentions(self._active_adapter)
+        self._active_adapter = adapter_name
+        self.peft_config[adapter_name] = config
+        self._create_adapted_attentions(config, parents)
+        if not self._enabled:
+            self._remove_adapted_attentions(self._active_adapter)
+
+        if config.inference_mode:
+            _freeze_adapter(self.model, adapter_name)
+
+    def set_adapter(self, adapter_name: str, inference_mode: bool = False) -> None:
+        """Set the model to use the adapter with the given name."""
+        if inference_mode:
+            raise ValueError("inference_mode is not supported for AdaptionPromptModel.")
+        if self._active_adapter == adapter_name:
+            return
+        if adapter_name not in self.peft_config:
+            raise ValueError(f"Adapter with name '{adapter_name}' does not exist.")
+
+        if self._enabled:
+            self._remove_adapted_attentions(self._active_adapter)
+            self._set_adapted_attentions(adapter_name)
+
+        self._active_adapter = adapter_name
+
+    def enable_adapter_layers(self):
+        """Enable adapter layers by swapping in cached AdaptedAttention modules."""
+        self._enabled = True
+        self._set_adapted_attentions(self._active_adapter)
+
+    def disable_adapter_layers(self):
+        """Disable adapter layers by swapping out AdaptedAttention modules."""
+        self._enabled = False
+        self._remove_adapted_attentions(self._active_adapter)
+
+    def _create_adapted_attentions(self, config: AdaptionPromptConfig, parents: list[nn.Module]) -> None:
+        """Wrap LlamaAttention modules with newly created AdaptedAttention modules."""
+        for par in parents:
+            if self.model.config.model_type == "gpt2":
+                attn = AdaptedAttentionGPT(
+                    model_type=self.model.config.model_type,
+                    adapter_len=config.adapter_len,
+                    model=getattr(par, config.target_modules),
+                )
+
+            else:
+                attn = AdaptedAttention(
+                    model_type=self.model.config.model_type,
+                    adapter_len=config.adapter_len,
+                    model=getattr(par, config.target_modules),
+                )
+            setattr(par, config.target_modules, attn)
+
+    def _set_adapted_attentions(self, adapter_name: str) -> None:
+        """Replace LlamaAttention modules with cached AdaptedAttention modules."""
+        cached = self._cached_adapters[adapter_name]
+        del self._cached_adapters[adapter_name]
+        config = self.peft_config[adapter_name]
+        for i, par in enumerate(self._parents[adapter_name]):
+            setattr(par, config.target_modules, cached[i])
+
+    def _remove_adapted_attentions(self, adapter_name: str) -> None:
+        """Remove AdaptedAttention modules from the model and store them in the cache."""
+        config = self.peft_config[adapter_name]
+        adapted_attentions = []
+        for par in self._parents[adapter_name]:
+            attn = getattr(par, config.target_modules)
+            adapted_attentions.append(attn)
+            setattr(par, config.target_modules, attn.model)
+        self._cached_adapters[adapter_name] = adapted_attentions
+
+    def _mark_only_adaption_prompts_as_trainable(self, model: nn.Module) -> None:
+        """Freeze all parameters of the model except the adaption prompts."""
+        for n, p in model.named_parameters():
+            if not is_adaption_prompt_trainable(n):
+                p.requires_grad = False
+
+    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:
+            # This is necessary as e.g. causal models have various methods that we
+            # don't want to re-implement here.
+            if name == "model":  # see #1892: prevent infinite recursion if class is not initialized
+                raise
+            return getattr(self.model, name)

tasks/tasksmith-749ff8d440e1/environment/source/src/peft/tuners/adaption_prompt/utils.py

@@ -0,0 +1,154 @@
+# 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 typing import Optional
+
+import torch
+from torch import nn
+
+
+def llama_rotate_half(x: torch.Tensor) -> torch.Tensor:
+    """
+    Rotate half the hidden dims of the input.
+
+    This function was duplicated verbatim from:
+    https://github.com/huggingface/transformers/blob/1de8ce9ee1191ba761a593ac15d9ccbf5851bfc5/src/transformers/models/llama/modeling_llama.py#L126
+
+    This was done to eliminate the Llama transformers implementation as a dependency of this file. Note that some other
+    functions were also adapted from the transformers implementation but were modified.
+    """
+    x1 = x[..., : x.shape[-1] // 2]
+    x2 = x[..., x.shape[-1] // 2 :]
+    return torch.cat((-x2, x1), dim=-1)
+
+
+def llama_apply_rotary_pos_emb(q, cos, sin, position_ids):
+    """
+    Apply rotary position embedding to query states in the Llama model.
+
+    This function was adapted from:
+    https://github.com/huggingface/transformers/blob/1de8ce9ee1191ba761a593ac15d9ccbf5851bfc5/src/transformers/models/llama/modeling_llama.py#L133
+
+    It was modified to remove unnecessary processing of key states. The method is compatible with transformers <=
+    4.34.2 and also with the latest version (>=4.35).
+    """
+    # In previous transformers version cos/sin cached had a shape of 4D
+    if len(cos.shape) == 4:
+        gather_indices = position_ids[:, None, :, None]  # [bs, 1, seq_len, 1]
+        gather_indices = gather_indices.repeat(1, cos.shape[1], 1, cos.shape[3])
+        cos = torch.gather(cos.repeat(gather_indices.shape[0], 1, 1, 1), 2, gather_indices)
+        sin = torch.gather(sin.repeat(gather_indices.shape[0], 1, 1, 1), 2, gather_indices)
+    # In the new version, it is 2D so we fall back to the new implementation
+    # https://github.com/huggingface/transformers/blame/eef7ea98c31a333bacdc7ae7a2372bde772be8e4/src/transformers/models/llama/modeling_llama.py#L222-L226
+    else:
+        cos = cos[position_ids].unsqueeze(1)
+        sin = sin[position_ids].unsqueeze(1)
+    q_embed = (q * cos) + (llama_rotate_half(q) * sin)
+    return q_embed
+
+
+def llama_compute_query_states(model: nn.Module, **kwargs) -> torch.Tensor:
+    """
+    Compute query states for Llama models specifically. They need to be recomputed as the forward() method of the
+    original LlamaModel in the transformers library does not return them. See the related discussion in the PR:
+    https://github.com/huggingface/peft/pull/268
+    """
+    hidden_states = kwargs.get("hidden_states")
+    position_ids = kwargs.get("position_ids")
+    past_key_value = kwargs.get("past_key_value")
+    bsz, q_len, _ = hidden_states.size()
+    num_heads = model.config.num_attention_heads
+    query_states = model.q_proj(hidden_states).view(bsz, q_len, num_heads, model.head_dim).transpose(1, 2)
+
+    factor = model.k_proj.in_features // model.k_proj.out_features
+    value_states = model.v_proj(hidden_states).view(bsz, q_len, (num_heads // factor), model.head_dim).transpose(1, 2)
+
+    seq_len = q_len
+
+    if past_key_value is not None:
+        if isinstance(past_key_value, tuple):
+            # for transformers <= 4.35
+            seq_len += past_key_value[0].shape[-2]
+        else:
+            # since transformers 4.36, this is a DynamicCache instance
+            seq_len += past_key_value.get_seq_length(model.layer_idx)
+
+    # model.rotary_emb is deprecated and will be removed in transformers > 4.47.0. Instead, the position embeddings are
+    # passed via the kwargs
+    if "position_embeddings" in kwargs:
+        cos, sin = kwargs["position_embeddings"]
+        cos = cos.unsqueeze(1)
+        sin = sin.unsqueeze(1)
+        return (query_states * cos) + (llama_rotate_half(query_states) * sin)
+
+    # For transformers > 4.37.2 `position_ids` became a required arguments in the rotary embedding's forward pass.
+    if "position_ids" not in inspect.signature(model.rotary_emb.forward).parameters:
+        # TODO we assume that position_ids is not None here, not sure if that is safe but the old code also did that
+        cos, sin = model.rotary_emb(value_states, seq_len=seq_len)
+        return llama_apply_rotary_pos_emb(query_states, cos, sin, position_ids)
+
+    past_seen_tokens = 0
+    if position_ids is None:
+        # Compute position_ids, since they are required for transformers > 4.37.2
+        if past_key_value is None:
+            new_cache_positions = torch.arange(q_len, q_len + q_len, device=value_states.device)
+        else:
+            past_seen_tokens = past_key_value.get_usable_length(q_len, model.layer_idx)
+            new_cache_positions = torch.arange(past_seen_tokens, past_seen_tokens + q_len, device=value_states.device)
+        position_ids = new_cache_positions.unsqueeze(0)
+
+    rotary_emb_kwargs = {"position_ids": position_ids}
+    # The `seq_len` argument has been officially removed in transformers >= 4.39.0
+    if "seq_len" in inspect.signature(model.rotary_emb.forward).parameters:
+        rotary_emb_kwargs["seq_len"] = q_len + past_seen_tokens
+
+    cos, sin = model.rotary_emb(value_states, **rotary_emb_kwargs)
+
+    # For batched inference unsqueeze it on the correct dim
+    # since: https://github.com/huggingface/transformers/pull/29109
+    if len(cos.shape) == 3:
+        cos = cos.unsqueeze(1)
+        sin = sin.unsqueeze(1)
+
+    return (query_states * cos) + (llama_rotate_half(query_states) * sin)
+
+
+def gpt2_compute_query_states(
+    model: nn.Module,
+    hidden_states: Optional[tuple[torch.FloatTensor]],
+    encoder_hidden_states: Optional[torch.Tensor] = None,
+) -> torch.Tensor:
+    """
+    Compute query states for GPT2 models. They need to be recomputed as the forward() method of the GPT@ in the
+    transformers library does not return them. See the related discussion in the PR:
+    """
+    if encoder_hidden_states is not None:
+        if not hasattr(model, "q_attn"):
+            raise ValueError(
+                f"If `{model.__class__.__name__}` is used as cross attention, the weights `q_attn` must be defined. "
+                f"Please make sure to instantiate it with `GPT2Attention(..., is_cross_attention=True)`."
+            )
+        query_states = model.q_attn(hidden_states)
+    else:
+        query_states, _, _ = model.c_attn(hidden_states).split(model.split_size, dim=2)
+
+    shape_q = (*query_states.shape[:-1], -1, model.head_dim)
+    query_states = query_states.view(shape_q).transpose(1, 2)
+
+    return query_states
+
+
+def is_adaption_prompt_trainable(params: str) -> bool:
+    """Return True if module is trainable under adaption prompt fine-tuning."""
+    return params.split(".")[-1].startswith("adaption_")

tasks/tasksmith-749ff8d440e1/environment/source/src/peft/tuners/beft/__init__.py

@@ -0,0 +1,24 @@
+# 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 BeftConfig
+from .layer import BeftLayer, Linear
+from .model import BeftModel
+
+
+__all__ = ["BeftConfig", "BeftLayer", "BeftModel", "Linear"]
+register_peft_method(name="beft", config_cls=BeftConfig, model_cls=BeftModel, is_mixed_compatible=True)

tasks/tasksmith-749ff8d440e1/environment/source/src/peft/tuners/beft/config.py

@@ -0,0 +1,73 @@
+# 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 Optional, Union
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class BeftConfig(PeftConfig):
+    """
+    This is the configuration class to store the configuration of a [`BeftModel`].
+
+    Args:
+        target_modules (`Optional[Union[List[str], str]]`):
+            The names of the modules to apply the adapter to. If this is specified, only the modules with the specified
+            names will be replaced. When passing a string, a regex match will be performed. When passing a list of
+            strings, either an exact match will be performed or it is checked if the name of the module ends with any
+            of the passed strings. If this is not specified, modules will be chosen according to the model
+            architecture. If the architecture is not known, an error will be raised -- in this case, you should specify
+            the target modules manually.
+        modules_to_save (`Optional[List[str]]`):
+            List of modules apart from BEFT layers to be set as trainable and saved in the final checkpoint.
+        init_weights (`bool`):
+            Whether to initialize the vectors in the BEFT layers, defaults to `True`. Setting this to `False` is
+            discouraged.
+    """
+
+    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 BEFT."
+                "For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'."
+                "If not specified, modules will be chosen according to the model architecture, If the architecture is "
+                "not known, an error will be raised -- in this case, you should specify the target modules manually."
+            ),
+        },
+    )
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": "List of modules apart from BEFT 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."
+        },
+    )
+    init_weights: bool = field(
+        default=True,
+        metadata={"help": "Whether to initialize the vectors in the BEFT layers."},
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.BEFT
+        self.target_modules = (
+            set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        )

tasks/tasksmith-749ff8d440e1/environment/source/src/peft/tuners/beft/layer.py

@@ -0,0 +1,166 @@
+# 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 warnings
+from typing import Any, Optional
+
+import torch
+from torch import nn
+
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+
+from .config import BeftConfig
+
+
+class BeftLayer(BaseTunerLayer):
+    # All names of layers that may contain adapter weights
+    adapter_layer_names = ("beft_bias",)
+
+    def __init__(self, base_layer: nn.Module, **kwargs) -> None:
+        self.base_layer = base_layer
+        self.beft_bias = nn.ParameterDict({})
+        # Mark the weight as unmerged
+        self._disable_adapters = False
+        self.merged_adapters = []
+
+        base_layer = self.get_base_layer()
+        if isinstance(base_layer, nn.Linear):
+            in_features, out_features = base_layer.in_features, base_layer.out_features
+        else:
+            raise TypeError(f"Unsupported layer type {type(base_layer)}")
+        self.in_features = in_features
+        self.out_features = out_features
+
+    def update_layer(self, adapter_name: str, config: BeftConfig, **kwargs):
+        base_layer = self.get_base_layer()
+        if base_layer.bias is None:
+            warnings.warn(
+                "Detected that the base layer has no bias term. "
+                "Note you cannot merge the BEFT adapter into the base layer."
+            )
+        init_weights = config.init_weights
+        inference_mode = config.inference_mode
+        weight = torch.randn((1, self.out_features))
+        self.beft_bias[adapter_name] = nn.Parameter(weight)
+        if init_weights:
+            self.reset_beft_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_beft_parameters(self, adapter_name):
+        if adapter_name in self.beft_bias.keys():
+            nn.init.constant_(self.beft_bias[adapter_name], 0.0)
+
+
+class Linear(nn.Module, BeftLayer):
+    # BEFT implemented in a dense layer
+    def __init__(
+        self,
+        base_layer: nn.Module,
+        adapter_name: str,
+        config: BeftConfig,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        BeftLayer.__init__(self, base_layer)
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, config=config)
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter bias into the base bias
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If True, the merge operation will be performed in a copy of the original bias and check for NaNs before
+                merging the bias. 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:
+            if active_adapter in self.beft_bias.keys():
+                base_layer = self.get_base_layer()
+
+                if base_layer.bias is None:
+                    raise ValueError(f"Base layer has no bias, cannot merge bias adapter {active_adapter}")
+
+                orig_dtype = base_layer.bias.data.dtype
+                beft_bias = self.beft_bias[active_adapter].data
+
+                if safe_merge:
+                    output_bias = (base_layer.bias.data + beft_bias.squeeze()).clone()
+
+                    if not torch.isfinite(output_bias).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    base_layer.bias.data = output_bias.to(orig_dtype)
+                else:
+                    base_layer.bias.data.add_(beft_bias.squeeze()).to(orig_dtype)
+
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        """
+        This method unmerges all merged adapter layers from the base bias.
+        """
+        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.beft_bias.keys():
+                base_layer = self.get_base_layer()
+
+                if base_layer.bias is None:
+                    raise ValueError(f"Base layer has no bias, cannot unmerge bias adapter {active_adapter}")
+
+                orig_dtype = base_layer.bias.data.dtype
+                # minus BEFT bias.
+                beft_bias = self.beft_bias[active_adapter].data
+                base_layer.bias.data = (base_layer.bias.data - beft_bias.squeeze()).to(orig_dtype)
+
+    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:
+            beft_bias = None
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.beft_bias.keys():
+                    continue
+                current_bias = self.beft_bias[active_adapter].flatten()
+                if beft_bias is None:
+                    beft_bias = current_bias
+                else:
+                    beft_bias = beft_bias + current_bias
+
+            result = self.base_layer(x, *args, **kwargs)
+            if beft_bias is not None:
+                orig_dtype = result.dtype
+                result = (result + beft_bias).to(orig_dtype)
+
+        return result

tasks/tasksmith-749ff8d440e1/environment/source/src/peft/tuners/beft/model.py

@@ -0,0 +1,103 @@
+# 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 torch
+
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer
+from peft.utils import (
+    TRANSFORMERS_MODELS_TO_BEFT_TARGET_MODULES_MAPPING,
+)
+
+from .layer import BeftLayer, Linear
+
+
+class BeftModel(BaseTuner):
+    """
+    Creates a Infused Adapter by only fine-tuning the added bias terms of value projections from a pretrained
+    transformers model in low-training-data regimes (BEFT). The method is described in detail in
+    https://arxiv.org/abs/2509.15974
+
+    Args:
+        model ([`~transformers.PreTrainedModel`]): The model to be adapted.
+        config ([`BeftConfig`]): The configuration of the (BEFT) 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 (BEFT) model.
+
+    Example:
+
+        ```py
+        >>> from transformers import AutoModelForSeq2SeqLM
+        >>> from peft import BeftModel, BeftConfig
+
+        >>> config = BeftConfig(
+        ...     peft_type="Beft",
+        ...     task_type="SEQ_2_SEQ_LM",
+        ...     target_modules=["v"],
+        ... )
+
+        >>> model = AutoModelForSeq2SeqLM.from_pretrained("t5-base")
+        >>> beft_model = BeftModel(model, config, adapter_name="default")
+        ```
+
+    **Attributes**:
+        - **model** ([`~transformers.PreTrainedModel`]) -- The model to be adapted.
+        - **peft_config** ([`BeftConfig`]): The configuration of the (BEFT) model.
+    """
+
+    prefix: str = "beft_"
+    tuner_layer_cls = BeftLayer
+    target_module_mapping = TRANSFORMERS_MODELS_TO_BEFT_TARGET_MODULES_MAPPING
+
+    @staticmethod
+    def _create_new_module(beft_config, adapter_name, target, **kwargs):
+        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, config=beft_config, **kwargs)
+        else:
+            raise TypeError(
+                f"Target module {target} is not supported. Currently, only `torch.nn.Linear` is supported."
+            )
+        return new_module
+
+    def _create_and_replace(
+        self,
+        beft_config,
+        adapter_name,
+        target,
+        target_name,
+        parent,
+        current_key,
+    ):
+        kwargs = {}
+
+        if isinstance(target, BeftLayer):
+            target.update_layer(
+                adapter_name,
+                config=beft_config,
+            )
+        else:
+            new_module = self._create_new_module(beft_config, adapter_name, target, **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)

tasks/tasksmith-749ff8d440e1/environment/source/src/peft/tuners/boft/__init__.py

@@ -0,0 +1,24 @@
+# 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 BOFTConfig
+from .layer import BOFTLayer
+from .model import BOFTModel
+
+
+__all__ = ["BOFTConfig", "BOFTLayer", "BOFTModel"]
+
+register_peft_method(name="boft", config_cls=BOFTConfig, model_cls=BOFTModel)