diff --git "a/huggingface_peft.txt" "b/huggingface_peft.txt"
new file mode 100644--- /dev/null
+++ "b/huggingface_peft.txt"
@@ -0,0 +1,11120 @@
+# File: peft-main/src/peft/__init__.py
+__version__ = '0.12.1.dev0'
+from .auto import AutoPeftModel, AutoPeftModelForCausalLM, AutoPeftModelForSequenceClassification, AutoPeftModelForSeq2SeqLM, AutoPeftModelForTokenClassification, AutoPeftModelForQuestionAnswering, AutoPeftModelForFeatureExtraction
+from .mapping import MODEL_TYPE_TO_PEFT_MODEL_MAPPING, PEFT_TYPE_TO_CONFIG_MAPPING, get_peft_config, get_peft_model, inject_adapter_in_model
+from .mixed_model import PeftMixedModel
+from .peft_model import PeftModel, PeftModelForCausalLM, PeftModelForSeq2SeqLM, PeftModelForSequenceClassification, PeftModelForTokenClassification, PeftModelForQuestionAnswering, PeftModelForFeatureExtraction, get_layer_status, get_model_status
+from .tuners import AdaptionPromptConfig, AdaptionPromptModel, LoraConfig, LoraRuntimeConfig, LoftQConfig, LoraModel, LoHaConfig, LoHaModel, LoKrConfig, LoKrModel, IA3Config, IA3Model, AdaLoraConfig, AdaLoraModel, BOFTConfig, BOFTModel, PrefixEncoder, PrefixTuningConfig, PromptEmbedding, PromptEncoder, PromptEncoderConfig, PromptEncoderReparameterizationType, PromptTuningConfig, PromptTuningInit, MultitaskPromptTuningConfig, MultitaskPromptTuningInit, OFTConfig, OFTModel, PolyConfig, PolyModel, LNTuningConfig, LNTuningModel, VBLoRAConfig, VBLoRAModel, VeraConfig, VeraModel, FourierFTConfig, FourierFTModel, XLoraConfig, XLoraModel, HRAConfig, HRAModel, VBLoRAConfig
+from .utils import TRANSFORMERS_MODELS_TO_PREFIX_TUNING_POSTPROCESS_MAPPING, PeftType, TaskType, bloom_model_postprocess_past_key_value, get_peft_model_state_dict, prepare_model_for_kbit_training, replace_lora_weights_loftq, set_peft_model_state_dict, shift_tokens_right, load_peft_weights, cast_mixed_precision_params
+from .config import PeftConfig, PromptLearningConfig
+
+# File: peft-main/src/peft/auto.py
+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 .mapping import MODEL_TYPE_TO_PEFT_MODEL_MAPPING
+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
+
+class _BaseAutoPeftModel:
+    _target_class = None
+    _target_peft_class = None
+
+    def __init__(self, *args, **kwargs):
+        raise EnvironmentError(f'{self.__class__.__name__} is designed to be instantiated using the `{self.__class__.__name__}.from_pretrained(pretrained_model_name_or_path)` or `{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, **kwargs):
+        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
+        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:
+            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']
+            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:
+            tokenizer = AutoTokenizer.from_pretrained(pretrained_model_name_or_path, trust_remote_code=kwargs.get('trust_remote_code', False))
+            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
+
+# File: peft-main/src/peft/config.py
+import inspect
+import json
+import os
+import warnings
+from dataclasses import asdict, dataclass, field
+from typing import Dict, Optional, Union
+from huggingface_hub import hf_hub_download
+from transformers.utils import PushToHubMixin
+from .utils import CONFIG_NAME, PeftType, TaskType
+
+@dataclass
+class PeftConfigMixin(PushToHubMixin):
+    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.'})
+
+    def to_dict(self) -> Dict:
+        return asdict(self)
+
+    def save_pretrained(self, save_directory: str, **kwargs) -> None:
+        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()
+        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)
+        if auto_mapping_dict is not None:
+            output_dict['auto_mapping'] = auto_mapping_dict
+        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):
+        from peft.mapping import PEFT_TYPE_TO_CONFIG_MAPPING
+        if 'peft_type' in kwargs:
+            peft_type = kwargs['peft_type']
+            config_cls = PEFT_TYPE_TO_CONFIG_MAPPING[peft_type]
+        else:
+            config_cls = cls
+        return config_cls(**kwargs)
+
+    @classmethod
+    def from_pretrained(cls, pretrained_model_name_or_path: str, subfolder: Optional[str]=None, **kwargs):
+        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 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}
+        return cls.from_peft_type(**kwargs)
+
+    @classmethod
+    def from_json_file(cls, path_json_file: str, **kwargs):
+        with open(path_json_file) as file:
+            json_object = json.load(file)
+        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']
+
+    @property
+    def is_prompt_learning(self) -> bool:
+        return False
+
+    @property
+    def is_adaption_prompt(self) -> bool:
+        return False
+
+@dataclass
+class PeftConfig(PeftConfigMixin):
+    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):
+    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'})
+
+    @property
+    def is_prompt_learning(self) -> bool:
+        return True
+
+# File: peft-main/src/peft/helpers.py
+import inspect
+from contextlib import contextmanager
+from copy import deepcopy
+from functools import update_wrapper
+from types import MethodType
+from .peft_model import PeftConfig, PeftModel
+from .tuners.lora.layer import LoraLayer
+
+def update_forward_signature(model: PeftModel) -> None:
+    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:
+    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:
+    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:
+    is_peft_model = True
+    try:
+        PeftConfig.from_pretrained(model_name_or_path)
+    except Exception:
+        is_peft_model = False
+    return is_peft_model
+
+@contextmanager
+def rescale_adapter_scale(model, multiplier):
+    if not isinstance(multiplier, (float, int)):
+        raise TypeError(f'Argument multiplier should be of type float, got {type(multiplier)}')
+    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()}
+    if not original_scaling:
+        raise ValueError('scaling is only supported for models with `LoraLayer`s')
+    try:
+        yield
+    finally:
+        for (module, scaling) in original_scaling.items():
+            module.scaling = scaling
+
+# File: peft-main/src/peft/import_utils.py
+import importlib
+import importlib.metadata as importlib_metadata
+from functools import lru_cache
+import packaging.version
+
+@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_auto_gptq_available():
+    if importlib.util.find_spec('auto_gptq') is not None:
+        AUTOGPTQ_MINIMUM_VERSION = packaging.version.parse('0.5.0')
+        version_autogptq = packaging.version.parse(importlib_metadata.version('auto_gptq'))
+        if AUTOGPTQ_MINIMUM_VERSION <= version_autogptq:
+            return True
+        else:
+            raise ImportError(f'Found an incompatible version of auto-gptq. Found version {version_autogptq}, but only versions above {AUTOGPTQ_MINIMUM_VERSION} 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):
+    if importlib.util.find_spec('torch_xla') is not None:
+        if check_device:
+            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():
+    return importlib.util.find_spec('aqlm') is not None
+
+@lru_cache
+def is_auto_awq_available():
+    return importlib.util.find_spec('awq') is not None
+
+@lru_cache
+def is_eetq_available():
+    return importlib.util.find_spec('eetq') is not None
+
+@lru_cache
+def is_hqq_available():
+    return importlib.util.find_spec('hqq') is not None
+
+# File: peft-main/src/peft/mapping.py
+from __future__ import annotations
+import warnings
+from typing import TYPE_CHECKING, Any, Optional
+import torch
+from peft.tuners.xlora.model import XLoraModel
+from .config import PeftConfig
+from .mixed_model import PeftMixedModel
+from .peft_model import PeftModel, PeftModelForCausalLM, PeftModelForFeatureExtraction, PeftModelForQuestionAnswering, PeftModelForSeq2SeqLM, PeftModelForSequenceClassification, PeftModelForTokenClassification
+from .tuners import AdaLoraConfig, AdaLoraModel, AdaptionPromptConfig, BOFTConfig, BOFTModel, FourierFTConfig, FourierFTModel, HRAConfig, HRAModel, IA3Config, IA3Model, LNTuningConfig, LNTuningModel, LoHaConfig, LoHaModel, LoKrConfig, LoKrModel, LoraConfig, LoraModel, MultitaskPromptTuningConfig, OFTConfig, OFTModel, PolyConfig, PolyModel, PrefixTuningConfig, PromptEncoderConfig, PromptTuningConfig, VBLoRAConfig, VBLoRAModel, VeraConfig, VeraModel, XLoraConfig
+from .tuners.tuners_utils import BaseTuner
+from .utils import _prepare_prompt_learning_config
+if TYPE_CHECKING:
+    from transformers import PreTrainedModel
+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}
+PEFT_TYPE_TO_CONFIG_MAPPING: dict[str, type[PeftConfig]] = {'ADAPTION_PROMPT': AdaptionPromptConfig, 'PROMPT_TUNING': PromptTuningConfig, 'PREFIX_TUNING': PrefixTuningConfig, 'P_TUNING': PromptEncoderConfig, 'LORA': LoraConfig, 'LOHA': LoHaConfig, 'LORAPLUS': LoraConfig, 'LOKR': LoKrConfig, 'ADALORA': AdaLoraConfig, 'BOFT': BOFTConfig, 'IA3': IA3Config, 'MULTITASK_PROMPT_TUNING': MultitaskPromptTuningConfig, 'OFT': OFTConfig, 'POLY': PolyConfig, 'LN_TUNING': LNTuningConfig, 'VERA': VeraConfig, 'FOURIERFT': FourierFTConfig, 'XLORA': XLoraConfig, 'HRA': HRAConfig, 'VBLORA': VBLoRAConfig}
+PEFT_TYPE_TO_TUNER_MAPPING: dict[str, type[BaseTuner]] = {'LORA': LoraModel, 'LOHA': LoHaModel, 'LOKR': LoKrModel, 'ADALORA': AdaLoraModel, 'BOFT': BOFTModel, 'IA3': IA3Model, 'OFT': OFTModel, 'POLY': PolyModel, 'LN_TUNING': LNTuningModel, 'VERA': VeraModel, 'FOURIERFT': FourierFTModel, 'XLORA': XLoraModel, 'HRA': HRAModel, 'VBLORA': VBLoRAModel}
+
+def get_peft_config(config_dict: dict[str, Any]) -> PeftConfig:
+    return PEFT_TYPE_TO_CONFIG_MAPPING[config_dict['peft_type']](**config_dict)
+
+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) -> PeftModel | PeftMixedModel:
+    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
+    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 mixed:
+        return PeftMixedModel(model, peft_config, adapter_name=adapter_name)
+    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)
+    if peft_config.is_prompt_learning:
+        peft_config = _prepare_prompt_learning_config(peft_config, model_config)
+    return MODEL_TYPE_TO_PEFT_MODEL_MAPPING[peft_config.task_type](model, peft_config, adapter_name=adapter_name, autocast_adapter_dtype=autocast_adapter_dtype)
+
+def inject_adapter_in_model(peft_config: PeftConfig, model: torch.nn.Module, adapter_name: str='default') -> torch.nn.Module:
+    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]
+    peft_model = tuner_cls(model, peft_config, adapter_name=adapter_name)
+    return peft_model.model
+
+# File: peft-main/src/peft/mixed_model.py
+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 AdaLoraModel, IA3Model, LoHaModel, LoKrModel, LoraModel, MixedModel, OFTModel
+from .tuners.mixed import COMPATIBLE_TUNER_TYPES
+from .utils import PeftType, _set_adapter, _set_trainable
+PEFT_TYPE_TO_MODEL_MAPPING = {PeftType.LORA: LoraModel, PeftType.LOHA: LoHaModel, PeftType.LOKR: LoKrModel, PeftType.ADALORA: AdaLoraModel, PeftType.IA3: IA3Model, PeftType.OFT: OFTModel}
+
+def _prepare_model_for_gradient_checkpointing(model: nn.Module) -> None:
+    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:
+    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`. Compatible types are: {COMPATIBLE_TUNER_TYPES}")
+
+class PeftMixedModel(PushToHubMixin, torch.nn.Module):
+
+    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)
+        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):
+        trainable_params = 0
+        all_param = 0
+        for (_, param) in self.named_parameters():
+            num_params = param.numel()
+            if num_params == 0 and hasattr(param, 'ds_numel'):
+                num_params = param.ds_numel
+            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):
+        (trainable_params, all_param) = self.get_nb_trainable_parameters()
+        print(f'trainable params: {trainable_params:,d} || all params: {all_param:,d} || trainable%: {100 * trainable_params / all_param:.4f}')
+
+    def __getattr__(self, name: str):
+        try:
+            return super().__getattr__(name)
+        except AttributeError:
+            if name == 'base_model':
+                raise
+            return getattr(self.base_model, name)
+
+    def forward(self, *args: Any, **kwargs: Any):
+        return self.base_model(*args, **kwargs)
+
+    def generate(self, *args: Any, **kwargs: Any):
+        return self.base_model.generate(*args, **kwargs)
+
+    @contextmanager
+    def disable_adapter(self):
+        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):
+        _check_config_compatible(peft_config)
+        try:
+            self.peft_config[adapter_name] = peft_config
+            self.base_model.inject_adapter(self, adapter_name)
+        except Exception:
+            if adapter_name in self.peft_config:
+                del self.peft_config[adapter_name]
+            raise
+        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)
+
+    def set_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.set_adapter(adapter_name)
+        _set_adapter(self, adapter_name)
+
+    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):
+        return self.base_model.merge_and_unload(*args, **kwargs)
+
+    def unload(self, *args: Any, **kwargs: Any):
+        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 load_adapter(self, model_id: str, adapter_name: str, *args: Any, **kwargs: Any):
+        output = PeftModel.load_adapter(self, model_id, adapter_name, *args, **kwargs)
+        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):
+        from .mapping import PEFT_TYPE_TO_CONFIG_MAPPING
+        if config is None:
+            config = PEFT_TYPE_TO_CONFIG_MAPPING[PeftConfig._get_peft_type(model_id, subfolder=kwargs.get('subfolder', None), revision=kwargs.get('revision', None), cache_dir=kwargs.get('cache_dir', None), use_auth_token=kwargs.get('use_auth_token', None))].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__}')
+        if config.peft_type not in PEFT_TYPE_TO_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:
+            raise ValueError('Cannot set a prompt learning adapter to trainable when loading pretrained adapter.')
+        else:
+            config.inference_mode = not is_trainable
+        model = cls(model, config, adapter_name)
+        model.load_adapter(model_id, adapter_name, is_trainable=is_trainable, **kwargs)
+        return model
+
+# File: peft-main/src/peft/optimizers/loraplus.py
+""""""
+from __future__ import annotations
+from operator import attrgetter
+import torch.nn as 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:
+    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-06)
+    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
+
+# File: peft-main/src/peft/peft_model.py
+from __future__ import annotations
+import collections
+import inspect
+import os
+import warnings
+from contextlib import contextmanager
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import Any, Literal, Optional, Union
+import packaging.version
+import torch
+import transformers
+from accelerate import dispatch_model, infer_auto_device_map
+from accelerate.hooks import AlignDevicesHook, add_hook_to_module, remove_hook_from_submodules
+from accelerate.utils import get_balanced_memory, named_module_tensors
+from huggingface_hub import HfFileSystem, ModelCard, ModelCardData, hf_hub_download
+from safetensors import safe_open
+from safetensors.torch import save_file as safe_save_file
+from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss
+from transformers import PreTrainedModel
+from transformers.modeling_outputs import QuestionAnsweringModelOutput, SequenceClassifierOutput, TokenClassifierOutput
+from transformers.utils import PushToHubMixin
+from peft.utils.constants import DUMMY_MODEL_CONFIG
+from . import __version__
+from .config import PeftConfig
+from .tuners import AdaLoraModel, AdaptionPromptModel, BOFTModel, FourierFTModel, HRAModel, IA3Model, LNTuningModel, LoHaModel, LoKrModel, LoraModel, MultitaskPromptEmbedding, OFTModel, PolyModel, PrefixEncoder, PromptEmbedding, PromptEncoder, VBLoRAModel, VeraModel, XLoraConfig, XLoraModel
+from .tuners.tuners_utils import BaseTuner, BaseTunerLayer
+from .utils import SAFETENSORS_WEIGHTS_NAME, TRANSFORMERS_MODELS_TO_PREFIX_TUNING_POSTPROCESS_MAPPING, WEIGHTS_NAME, PeftType, TaskType, _get_batch_size, _prepare_prompt_learning_config, _set_adapter, _set_trainable, get_peft_model_state_dict, id_tensor_storage, infer_device, load_peft_weights, set_peft_model_state_dict, shift_tokens_right
+PEFT_TYPE_TO_MODEL_MAPPING = {PeftType.LORA: LoraModel, PeftType.LOHA: LoHaModel, PeftType.LOKR: LoKrModel, PeftType.PROMPT_TUNING: PromptEmbedding, PeftType.P_TUNING: PromptEncoder, PeftType.PREFIX_TUNING: PrefixEncoder, PeftType.ADALORA: AdaLoraModel, PeftType.BOFT: BOFTModel, PeftType.ADAPTION_PROMPT: AdaptionPromptModel, PeftType.IA3: IA3Model, PeftType.OFT: OFTModel, PeftType.POLY: PolyModel, PeftType.LN_TUNING: LNTuningModel, PeftType.VERA: VeraModel, PeftType.FOURIERFT: FourierFTModel, PeftType.XLORA: XLoraModel, PeftType.HRA: HRAModel, PeftType.VBLORA: VBLoRAModel}
+
+class PeftModel(PushToHubMixin, torch.nn.Module):
+
+    def __init__(self, model: PreTrainedModel, peft_config: PeftConfig, adapter_name: str='default', autocast_adapter_dtype: bool=True) -> None:
+        super().__init__()
+        self.modules_to_save = None
+        self.active_adapter = adapter_name
+        self.peft_type = peft_config.peft_type
+        self.special_peft_forward_args = {'adapter_names'}
+        self._is_prompt_learning = peft_config.is_prompt_learning
+        if self._is_prompt_learning:
+            self._peft_config = {adapter_name: peft_config}
+            self.base_model = model
+            self.add_adapter(adapter_name, peft_config)
+        else:
+            self._peft_config = None
+            cls = PEFT_TYPE_TO_MODEL_MAPPING[peft_config.peft_type]
+            self.base_model = cls(model, {adapter_name: peft_config}, adapter_name)
+            self.set_additional_trainable_modules(peft_config, adapter_name)
+        if hasattr(self.base_model, '_cast_adapter_dtype'):
+            self.base_model._cast_adapter_dtype(adapter_name=adapter_name, autocast_adapter_dtype=autocast_adapter_dtype)
+        if getattr(model, 'is_gradient_checkpointing', True):
+            model = self._prepare_model_for_gradient_checkpointing(model)
+        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]:
+        if self._is_prompt_learning:
+            return self._peft_config
+        return self.base_model.peft_config
+
+    @property
+    def active_adapters(self) -> list[str]:
+        try:
+            adapters = self.base_model.active_adapters
+            if not isinstance(adapters, list):
+                adapters = self.active_adapter
+                if isinstance(adapters, str):
+                    adapters = [adapters]
+        except AttributeError:
+            adapters = self.active_adapter
+            if isinstance(adapters, str):
+                adapters = [adapters]
+        return adapters
+
+    @peft_config.setter
+    def peft_config(self, value: dict[str, PeftConfig]):
+        if self._is_prompt_learning:
+            self._peft_config = value
+        else:
+            self.base_model.peft_config = value
+
+    def save_pretrained(self, save_directory: str, safe_serialization: bool=True, selected_adapters: Optional[list[str]]=None, save_embedding_layers: Union[str, bool]='auto', is_main_process: bool=True, convert_pissa_to_lora: Optional[str]=None, path_initial_model_for_weight_conversion: Optional[str]=None, **kwargs: Any) -> None:
+        if os.path.isfile(save_directory):
+            raise ValueError(f'Provided path ({save_directory}) should be a directory, not a file')
+        if selected_adapters is None:
+            selected_adapters = list(self.peft_config.keys())
+        elif any((selected_adapter_name not in list(self.peft_config.keys()) for selected_adapter_name in selected_adapters)):
+            raise ValueError(f'You passed an invalid `selected_adapters` arguments, current supported adapter names are {list(self.peft_config.keys())} - got {selected_adapters}.')
+        if convert_pissa_to_lora is not None:
+            warnings.warn('`convert_pissa_to_lora` is deprecated and will be removed in a future version. Use `path_initial_model_for_weight_conversion` instead.')
+            path_initial_model_for_weight_conversion = convert_pissa_to_lora
+
+        def save_mutated_as_lora(peft_config, path_initial_model_for_weight_conversion, output_state_dict, kwargs):
+            if peft_config.use_rslora and (peft_config.rank_pattern or peft_config.alpha_pattern):
+                msg = 'Passing `path_initial_model_for_weight_conversion` to `save_pretrained` is not supported when using `rank_pattern` or `alpha_pattern` at the same time as `use_rslora=True`.'
+                raise ValueError(msg)
+            if not any((str(peft_config.init_lora_weights).lower().startswith(prefix) for prefix in ['pissa', 'olora', 'true'])):
+                warnings.warn('`path_initial_model_for_weight_conversion` only works for converting a PiSSA or OLoRA adapter to a LoRA adapter')
+            initial_adapter_name = os.path.basename(path_initial_model_for_weight_conversion)
+            try:
+                self.load_adapter(os.path.dirname(path_initial_model_for_weight_conversion), subfolder=initial_adapter_name, adapter_name=initial_adapter_name)
+                is_pissa = str(self.peft_config[initial_adapter_name].init_lora_weights).lower().startswith('pissa')
+                is_olora = str(self.peft_config[initial_adapter_name].init_lora_weights).lower() == 'olora'
+                if is_pissa or is_olora:
+                    raise ValueError('The `init_lora_weights` parameter of the initial adapter should be set to `True`. Otherwise, `self.load_adapter` will subtract the decomposed values again based on the residual model.')
+                output_state_dict = self.base_model.subtract_mutated_init(output_state_dict, initial_adapter_name, kwargs)
+            finally:
+                self.delete_adapter(initial_adapter_name)
+            return output_state_dict
+        if is_main_process:
+            os.makedirs(save_directory, exist_ok=True)
+            self.create_or_update_model_card(save_directory)
+        for adapter_name in selected_adapters:
+            peft_config = self.peft_config[adapter_name]
+            output_state_dict = get_peft_model_state_dict(self, state_dict=kwargs.get('state_dict', None), adapter_name=adapter_name, save_embedding_layers=save_embedding_layers)
+            output_dir = os.path.join(save_directory, adapter_name) if adapter_name != 'default' else save_directory
+            os.makedirs(output_dir, exist_ok=True)
+            if is_main_process and safe_serialization:
+                ptrs = collections.defaultdict(list)
+                for (name, tensor) in output_state_dict.items():
+                    if isinstance(tensor, torch.Tensor):
+                        ptrs[id_tensor_storage(tensor)].append(name)
+                    else:
+                        ptrs[id(tensor)].append(name)
+                shared_ptrs = {ptr: names for (ptr, names) in ptrs.items() if len(names) > 1}
+                for (_, names) in shared_ptrs.items():
+                    for shared_tensor_name in names[1:]:
+                        output_state_dict[shared_tensor_name] = output_state_dict[shared_tensor_name].clone()
+                if path_initial_model_for_weight_conversion is not None:
+                    peft_config.init_lora_weights = True
+                    peft_config.save_pretrained(path_initial_model_for_weight_conversion)
+                    output_state_dict = save_mutated_as_lora(peft_config, path_initial_model_for_weight_conversion, output_state_dict, kwargs)
+                safe_save_file(output_state_dict, os.path.join(output_dir, SAFETENSORS_WEIGHTS_NAME), metadata={'format': 'pt'})
+            elif is_main_process:
+                if path_initial_model_for_weight_conversion is not None:
+                    peft_config.init_lora_weights = True
+                    peft_config.save_pretrained(path_initial_model_for_weight_conversion)
+                    output_state_dict = save_mutated_as_lora(peft_config, path_initial_model_for_weight_conversion, output_state_dict, kwargs)
+                torch.save(output_state_dict, os.path.join(output_dir, WEIGHTS_NAME))
+            if peft_config.base_model_name_or_path is None:
+                peft_config.base_model_name_or_path = self.base_model.__dict__.get('name_or_path', None) if peft_config.is_prompt_learning else self.base_model.model.__dict__.get('name_or_path', None)
+            inference_mode = peft_config.inference_mode
+            peft_config.inference_mode = True
+            if peft_config.task_type is None:
+                base_model_class = self._get_base_model_class(is_prompt_tuning=peft_config.is_prompt_learning)
+                parent_library = base_model_class.__module__
+                auto_mapping_dict = {'base_model_class': base_model_class.__name__, 'parent_library': parent_library}
+            else:
+                auto_mapping_dict = None
+            if is_main_process:
+                if path_initial_model_for_weight_conversion is not None:
+                    peft_config.init_lora_weights = True
+                    peft_config.r *= 2
+                    if not peft_config.use_rslora:
+                        peft_config.lora_alpha *= 2
+                    else:
+                        peft_config.lora_alpha *= 2 ** 0.5
+                    if peft_config.rank_pattern:
+                        peft_config.rank_pattern = {key: 2 * val for (key, val) in peft_config.rank_pattern.items()}
+                    if peft_config.alpha_pattern:
+                        peft_config.alpha_pattern = {key: 2 * val for (key, val) in peft_config.alpha_pattern.items()}
+                peft_config.save_pretrained(output_dir, auto_mapping_dict=auto_mapping_dict)
+            peft_config.inference_mode = inference_mode
+
+    @classmethod
+    def from_pretrained(cls, model: torch.nn.Module, model_id: Union[str, os.PathLike], adapter_name: str='default', is_trainable: bool=False, config: Optional[PeftConfig]=None, autocast_adapter_dtype: bool=True, ephemeral_gpu_offload: bool=False, **kwargs: Any) -> PeftModel:
+        from .mapping import MODEL_TYPE_TO_PEFT_MODEL_MAPPING, PEFT_TYPE_TO_CONFIG_MAPPING
+        if config is None:
+            config = PEFT_TYPE_TO_CONFIG_MAPPING[PeftConfig._get_peft_type(model_id, subfolder=kwargs.get('subfolder', None), revision=kwargs.get('revision', None), cache_dir=kwargs.get('cache_dir', None), use_auth_token=kwargs.get('use_auth_token', None), token=kwargs.get('token', None))].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__}')
+        if hasattr(config, 'runtime_config'):
+            config.runtime_config.ephemeral_gpu_offload = ephemeral_gpu_offload
+        elif ephemeral_gpu_offload:
+            warnings.warn('Ephemeral GPU offloading is not supported for this model. Ignoring.')
+        if hasattr(model, 'hf_device_map'):
+            weight_map = dict(named_module_tensors(model, recurse=True))
+            disk_modules = set()
+            index = None
+            for (name, module) in model.named_modules():
+                if hasattr(module, '_hf_hook') and hasattr(module._hf_hook, 'original_devices'):
+                    if hasattr(module._hf_hook.weights_map, 'dataset'):
+                        index = module._hf_hook.weights_map.dataset.index
+                    for key in module._hf_hook.original_devices.keys():
+                        if module._hf_hook.original_devices[key] == torch.device('meta'):
+                            disk_modules.add(str(name) + '.' + str(key))
+            if disk_modules and (not kwargs.get('use_safetensors', True)):
+                raise ValueError('Disk offloading currently only supported for safetensors')
+            if index:
+                offload_index = {p: {'safetensors_file': index[p]['safetensors_file'], 'weight_name': p, 'dtype': str(weight_map[p].dtype).replace('torch.', '')} for p in weight_map.keys() if p in disk_modules}
+                kwargs['offload_index'] = offload_index
+        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:
+            raise ValueError('Cannot set a prompt learning adapter to trainable when loading pretrained adapter.')
+        else:
+            config.inference_mode = not is_trainable
+        if isinstance(getattr(model, 'base_model', None), XLoraModel):
+            if not isinstance(config, XLoraConfig):
+                raise TypeError(f"Expected 'XLoraConfig', got '{type(config)}' instead.")
+            if 'adapters' in kwargs:
+                config.adapters = kwargs['adapters']
+            elif not os.path.exists(model_id):
+                s = HfFileSystem()
+                adapter_names = [file['name'][len(model_id) + 1:] for file in s.ls(model_id) if file['type'] == 'directory']
+                adapter_paths = {}
+                for adapter_name in adapter_names:
+                    adapter_paths[adapter_name] = os.path.join(model_id, model_id)
+                config.adapters = adapter_paths
+                config._subfolders = adapter_names
+            elif 'adapters' not in kwargs:
+                raise ValueError('If model_id is a local path, then `adapters` must be passed in kwargs.')
+        if config.task_type not in MODEL_TYPE_TO_PEFT_MODEL_MAPPING.keys():
+            model = cls(model, config, adapter_name, autocast_adapter_dtype=autocast_adapter_dtype)
+        else:
+            model = MODEL_TYPE_TO_PEFT_MODEL_MAPPING[config.task_type](model, config, adapter_name, autocast_adapter_dtype=autocast_adapter_dtype)
+        model.load_adapter(model_id, adapter_name, is_trainable=is_trainable, autocast_adapter_dtype=autocast_adapter_dtype, **kwargs)
+        return model
+
+    def _setup_prompt_encoder(self, adapter_name: str):
+        config = self.peft_config[adapter_name]
+        if not hasattr(self, 'prompt_encoder'):
+            self.prompt_encoder = torch.nn.ModuleDict({})
+            self.prompt_tokens = {}
+        transformer_backbone = None
+        for (name, module) in self.base_model.named_children():
+            for param in module.parameters():
+                param.requires_grad = False
+            if isinstance(module, PreTrainedModel):
+                if transformer_backbone is None:
+                    transformer_backbone = module
+                    self.transformer_backbone_name = name
+        if transformer_backbone is None:
+            transformer_backbone = self.base_model
+        if config.num_transformer_submodules is None:
+            config.num_transformer_submodules = 2 if config.task_type == TaskType.SEQ_2_SEQ_LM else 1
+        for (named_param, value) in list(transformer_backbone.named_parameters()):
+            deepspeed_distributed_tensor_shape = getattr(value, 'ds_shape', None)
+            if value.shape[0] == self.base_model.config.vocab_size or (deepspeed_distributed_tensor_shape is not None and deepspeed_distributed_tensor_shape[0] == self.base_model.config.vocab_size):
+                self.word_embeddings = transformer_backbone.get_submodule(named_param.replace('.weight', ''))
+                break
+        if config.peft_type == PeftType.PROMPT_TUNING:
+            prompt_encoder = PromptEmbedding(config, self.word_embeddings)
+        elif config.peft_type == PeftType.MULTITASK_PROMPT_TUNING:
+            prompt_encoder = MultitaskPromptEmbedding(config, self.word_embeddings)
+        elif config.peft_type == PeftType.P_TUNING:
+            prompt_encoder = PromptEncoder(config)
+        elif config.peft_type == PeftType.PREFIX_TUNING:
+            prompt_encoder = PrefixEncoder(config)
+        else:
+            raise ValueError('Not supported')
+        prompt_encoder = prompt_encoder.to(self.device)
+        self.prompt_encoder.update(torch.nn.ModuleDict({adapter_name: prompt_encoder}))
+        self.prompt_tokens[adapter_name] = torch.arange(config.num_virtual_tokens * config.num_transformer_submodules).long()
+
+    def _prepare_model_for_gradient_checkpointing(self, model: PreTrainedModel):
+        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)
+        return model
+
+    def get_prompt_embedding_to_save(self, adapter_name: str) -> torch.Tensor:
+        prompt_encoder = self.prompt_encoder[adapter_name]
+        prompt_tokens = self.prompt_tokens[adapter_name].unsqueeze(0).expand(1, -1).to(prompt_encoder.embedding.weight.device)
+        if self.peft_config[adapter_name].peft_type == PeftType.PREFIX_TUNING:
+            prompt_tokens = prompt_tokens[:, :self.peft_config[adapter_name].num_virtual_tokens]
+        if self.peft_config[adapter_name].peft_type == PeftType.MULTITASK_PROMPT_TUNING:
+            prompt_embeddings = super(MultitaskPromptEmbedding, prompt_encoder).forward(prompt_tokens)
+        else:
+            prompt_embeddings = prompt_encoder(prompt_tokens)
+        return prompt_embeddings[0].detach().cpu()
+
+    def get_prompt(self, batch_size: int, task_ids: Optional[torch.Tensor]=None) -> torch.Tensor:
+        peft_config = self.active_peft_config
+        prompt_encoder = self.prompt_encoder[self.active_adapter]
+        prompt_tokens = self.prompt_tokens[self.active_adapter].unsqueeze(0).expand(batch_size, -1).to(prompt_encoder.embedding.weight.device)
+        if peft_config.peft_type == PeftType.PREFIX_TUNING:
+            prompt_tokens = prompt_tokens[:, :peft_config.num_virtual_tokens]
+            if peft_config.inference_mode:
+                past_key_values = prompt_encoder.embedding.weight.repeat(batch_size, 1, 1)
+            else:
+                past_key_values = prompt_encoder(prompt_tokens)
+            if self.base_model_torch_dtype is not None:
+                past_key_values = past_key_values.to(self.base_model_torch_dtype)
+            past_key_values = past_key_values.view(batch_size, peft_config.num_virtual_tokens, peft_config.num_layers * 2, peft_config.num_attention_heads, peft_config.token_dim // peft_config.num_attention_heads)
+            if peft_config.num_transformer_submodules == 2:
+                past_key_values = torch.cat([past_key_values, past_key_values], dim=2)
+            past_key_values = past_key_values.permute([2, 0, 3, 1, 4]).split(peft_config.num_transformer_submodules * 2)
+            if TRANSFORMERS_MODELS_TO_PREFIX_TUNING_POSTPROCESS_MAPPING.get(self.config.model_type, None) is not None:
+                post_process_fn = TRANSFORMERS_MODELS_TO_PREFIX_TUNING_POSTPROCESS_MAPPING[self.config.model_type]
+                past_key_values = post_process_fn(past_key_values)
+            return past_key_values
+        else:
+            if peft_config.peft_type == PeftType.MULTITASK_PROMPT_TUNING:
+                prompts = prompt_encoder(prompt_tokens, task_ids)
+            else:
+                if peft_config.inference_mode:
+                    prompts = prompt_encoder.embedding.weight
+                else:
+                    prompt_tokens = prompt_tokens[:1]
+                    prompts = prompt_encoder(prompt_tokens)
+                prompts = prompts.repeat(batch_size, 1, 1)
+            return prompts
+
+    def get_nb_trainable_parameters(self) -> tuple[int, int]:
+        trainable_params = 0
+        all_param = 0
+        for (_, param) in self.named_parameters():
+            num_params = param.numel()
+            if num_params == 0 and hasattr(param, 'ds_numel'):
+                num_params = param.ds_numel
+            if param.__class__.__name__ == 'Params4bit':
+                if hasattr(param, 'element_size'):
+                    num_bytes = param.element_size()
+                elif not hasattr(param, 'quant_storage'):
+                    num_bytes = 1
+                else:
+                    num_bytes = param.quant_storage.itemsize
+                num_params = num_params * 2 * num_bytes
+            all_param += num_params
+            if param.requires_grad:
+                trainable_params += num_params
+        return (trainable_params, all_param)
+
+    def print_trainable_parameters(self) -> None:
+        (trainable_params, all_param) = self.get_nb_trainable_parameters()
+        print(f'trainable params: {trainable_params:,d} || all params: {all_param:,d} || trainable%: {100 * trainable_params / all_param:.4f}')
+
+    def __getattr__(self, name: str):
+        try:
+            return super().__getattr__(name)
+        except AttributeError:
+            if name == 'base_model':
+                raise
+            return getattr(self.base_model, name)
+
+    @contextmanager
+    def _enable_peft_forward_hooks(self, *args, **kwargs):
+        if hasattr(self.base_model, '_enable_peft_forward_hooks'):
+            with self.base_model._enable_peft_forward_hooks(*args, **kwargs):
+                yield
+            return
+        else:
+            yield
+            return
+
+    def forward(self, *args: Any, **kwargs: Any):
+        with self._enable_peft_forward_hooks(*args, **kwargs):
+            kwargs = {k: v for (k, v) in kwargs.items() if k not in self.special_peft_forward_args}
+            return self.get_base_model()(*args, **kwargs)
+
+    def generate(self, *args, **kwargs):
+        with self._enable_peft_forward_hooks(*args, **kwargs):
+            kwargs = {k: v for (k, v) in kwargs.items() if k not in self.special_peft_forward_args}
+            return self.get_base_model().generate(*args, **kwargs)
+
+    def _get_base_model_class(self, is_prompt_tuning=False):
+        if not is_prompt_tuning:
+            return self.base_model.model.__class__
+        return self.base_model.__class__
+
+    @contextmanager
+    def disable_adapter(self):
+        if self.peft_config[self.active_adapter].is_prompt_learning:
+            try:
+                old_forward = self.forward
+                self.forward = self.base_model.forward
+                old_prepare_inputs_for_generation = self.prepare_inputs_for_generation
+                self.prepare_inputs_for_generation = self.base_model.prepare_inputs_for_generation
+                yield
+            finally:
+                self.forward = old_forward
+                self.prepare_inputs_for_generation = old_prepare_inputs_for_generation
+        elif self.peft_config[self.active_adapter].is_adaption_prompt:
+            try:
+                self.base_model.disable_adapter_layers()
+                yield
+            finally:
+                self.base_model.enable_adapter_layers()
+        else:
+            model_status = self.get_model_status()
+            if model_status.enabled == 'irregular':
+                warnings.warn('The model contains some adapter layers that are enabled and others that are disabled. This is most likely unintentional. After exiting the disable_adapter context, all adapters will be enabled')
+            try:
+                self.base_model.disable_adapter_layers()
+                yield
+            finally:
+                if model_status.enabled is not False:
+                    self.base_model.enable_adapter_layers()
+
+    def get_base_model(self) -> torch.nn.Module:
+        return self.base_model if self.active_peft_config.is_prompt_learning or self.peft_type == PeftType.POLY else self.base_model.model
+
+    def add_adapter(self, adapter_name: str, peft_config: PeftConfig) -> None:
+        if peft_config.peft_type != self.peft_type:
+            raise ValueError(f'Cannot combine adapters with different peft types. Found {self.peft_type} and {peft_config.peft_type}.')
+        try:
+            if peft_config.is_prompt_learning:
+                self.peft_config[adapter_name] = peft_config
+                if hasattr(self.config, 'to_dict'):
+                    dict_config = self.config.to_dict()
+                else:
+                    dict_config = self.config
+                peft_config = _prepare_prompt_learning_config(peft_config, dict_config)
+                self._setup_prompt_encoder(adapter_name)
+            elif peft_config.is_adaption_prompt:
+                self.base_model.add_adapter(adapter_name, peft_config)
+            else:
+                self.peft_config[adapter_name] = peft_config
+                self.base_model.inject_adapter(self.base_model.model, adapter_name)
+        except Exception:
+            if adapter_name in self.peft_config:
+                del self.peft_config[adapter_name]
+            raise
+        self.set_additional_trainable_modules(peft_config, adapter_name)
+
+    def set_additional_trainable_modules(self, peft_config, adapter_name):
+        if getattr(peft_config, 'modules_to_save', None) is not None:
+            if self.modules_to_save is None:
+                self.modules_to_save = set(peft_config.modules_to_save)
+            else:
+                self.modules_to_save.update(peft_config.modules_to_save)
+            _set_trainable(self, adapter_name)
+
+    def get_layer_status(self) -> list[TunerLayerStatus]:
+        return get_layer_status(self)
+
+    def get_model_status(self) -> TunerModelStatus:
+        return get_model_status(self)
+
+    @classmethod
+    def _split_kwargs(cls, kwargs: dict[str, Any]):
+        _kwargs_not_in_hf_hub_download_signature = ('use_auth_token',)
+        hf_hub_download_kwargs = {}
+        other_kwargs = {}
+        for (key, value) in kwargs.items():
+            if key in inspect.signature(hf_hub_download).parameters or key in _kwargs_not_in_hf_hub_download_signature:
+                hf_hub_download_kwargs[key] = value
+            else:
+                other_kwargs[key] = value
+        return (hf_hub_download_kwargs, other_kwargs)
+
+    def _update_offload(self, offload_index: dict[str, dict[str, str]], adapters_weights: dict[str, torch.tensor]):
+        if not offload_index:
+            return offload_index
+        prefix = 'base_model.model.'
+        adapter_names = list(self.peft_config.keys())
+        for adapter_name in adapter_names:
+            keys = list(offload_index.keys())
+            block_id = keys[0].split('.')[0] + '.'
+            for key in keys:
+                suffix_pos = key.rfind('.')
+                extended_prefix = prefix + key[:suffix_pos]
+                module = dict(self.named_modules())[extended_prefix]
+                if isinstance(module, BaseTunerLayer):
+                    new_key = prefix + key[:suffix_pos] + '.base_layer' + key[suffix_pos:]
+                else:
+                    new_key = prefix + key
+                offload_index[key]['weight_name'] = new_key
+                offload_index[new_key] = offload_index[key]
+                del offload_index[key]
+            files_seen = set()
+            for new_key in list(offload_index.keys()):
+                fname = offload_index[new_key]['safetensors_file']
+                new_fname_list = list(fname.split(os.sep))
+                for (i, name) in enumerate(new_fname_list):
+                    if '--' in name:
+                        new_fname_list[i] += '-peft'
+                        break
+                new_fname = os.path.join(*new_fname_list)
+                if fname in files_seen:
+                    continue
+                safe_dict = {}
+                with safe_open(fname, framework='pt') as f:
+                    for safe_key in f.keys():
+                        safe_tensor = f.get_tensor(safe_key)
+                        metadata = f.metadata()
+                        suffix_pos = safe_key.rfind('.')
+                        extended_prefix = prefix + block_id + safe_key[:suffix_pos]
+                        safe_module = dict(self.named_modules())[extended_prefix]
+                        if isinstance(safe_module, BaseTunerLayer):
+                            final_key = extended_prefix + '.base_layer' + safe_key[suffix_pos:]
+                            lora_dict = {key: val for (key, val) in adapters_weights.items() if extended_prefix in key}
+                            for (lora_key, lora_val) in lora_dict.items():
+                                divide = lora_key.rfind('.')
+                                new_key = lora_key[:divide] + f'.{adapter_name}' + lora_key[divide:]
+                                safe_dict[new_key] = lora_val
+                        else:
+                            final_key = prefix + block_id + safe_key
+                        safe_dict[final_key] = safe_tensor
+                    files_seen.add(new_fname)
+                    for key in safe_dict.keys():
+                        offload_index[key] = {'safetensors_file': new_fname, 'weight_name': key}
+                    base_name = os.path.dirname(new_fname)
+                    if not os.path.exists(base_name):
+                        os.makedirs(base_name)
+                    safe_save_file(safe_dict, new_fname, metadata=metadata)
+
+    def load_adapter(self, model_id: str, adapter_name: str, is_trainable: bool=False, torch_device: Optional[str]=None, autocast_adapter_dtype: bool=True, ephemeral_gpu_offload: bool=False, **kwargs: Any):
+        from .mapping import PEFT_TYPE_TO_CONFIG_MAPPING
+        (hf_hub_download_kwargs, kwargs) = self._split_kwargs(kwargs)
+        if torch_device is None:
+            torch_device = infer_device()
+        if adapter_name not in self.peft_config:
+            peft_config = PEFT_TYPE_TO_CONFIG_MAPPING[PeftConfig._get_peft_type(model_id, **hf_hub_download_kwargs)].from_pretrained(model_id, ephemeral_gpu_offload=ephemeral_gpu_offload, **hf_hub_download_kwargs)
+            if peft_config.is_prompt_learning and is_trainable:
+                raise ValueError('Cannot set a prompt learning adapter to trainable when loading pretrained adapter.')
+            else:
+                peft_config.inference_mode = not is_trainable
+            self.add_adapter(adapter_name, peft_config)
+        adapters_weights = load_peft_weights(model_id, device=torch_device, **hf_hub_download_kwargs)
+        ignore_mismatched_sizes = kwargs.get('ignore_mismatched_sizes', False)
+        load_result = set_peft_model_state_dict(self, adapters_weights, adapter_name=adapter_name, ignore_mismatched_sizes=ignore_mismatched_sizes)
+        if getattr(self, 'hf_device_map', None) is not None and len(set(self.hf_device_map.values()).intersection({'cpu', 'disk'})) > 0 and (len(self.peft_config) == 1):
+            device_map = kwargs.get('device_map', 'auto')
+            max_memory = kwargs.get('max_memory', None)
+            offload_dir = kwargs.get('offload_folder', None)
+            offload_index = kwargs.get('offload_index', None)
+            dispatch_model_kwargs = {}
+            if 'offload_index' in inspect.signature(dispatch_model).parameters:
+                dispatch_model_kwargs['offload_index'] = offload_index
+            no_split_module_classes = self._no_split_modules
+            if device_map != 'sequential':
+                max_memory = get_balanced_memory(self, max_memory=max_memory, no_split_module_classes=no_split_module_classes, low_zero=device_map == 'balanced_low_0')
+            if isinstance(device_map, str):
+                device_map = infer_auto_device_map(self, max_memory=max_memory, no_split_module_classes=no_split_module_classes)
+            self._update_offload(offload_index, adapters_weights)
+            dispatch_model_kwargs['offload_index'] = offload_index
+            dispatch_model(self, device_map=device_map, offload_dir=offload_dir, **dispatch_model_kwargs)
+            hook = AlignDevicesHook(io_same_device=True)
+            if self.peft_config[adapter_name].is_prompt_learning:
+                remove_hook_from_submodules(self.prompt_encoder)
+            add_hook_to_module(self.get_base_model(), hook)
+        if hasattr(self.base_model, '_cast_adapter_dtype'):
+            self.base_model._cast_adapter_dtype(adapter_name=adapter_name, autocast_adapter_dtype=autocast_adapter_dtype)
+        if not is_trainable:
+            self.eval()
+        return load_result
+
+    def set_adapter(self, adapter_name: str) -> None:
+        if adapter_name not in self.peft_config:
+            raise ValueError(f'Adapter {adapter_name} not found.')
+        self.active_adapter = adapter_name
+        if not self.peft_config[adapter_name].is_prompt_learning:
+            self.base_model.set_adapter(adapter_name)
+        _set_adapter(self, adapter_name)
+
+    @property
+    def base_model_torch_dtype(self):
+        return getattr(self.base_model, 'dtype', None)
+
+    @property
+    def active_peft_config(self):
+        return self.peft_config[self.active_adapter]
+
+    def create_or_update_model_card(self, output_dir: str):
+        filename = os.path.join(output_dir, 'README.md')
+        card = ModelCard.load(filename) if os.path.exists(filename) else ModelCard.from_template(ModelCardData())
+        card.data['library_name'] = 'peft'
+        model_config = BaseTuner.get_model_config(self)
+        model_config = None if model_config == DUMMY_MODEL_CONFIG else model_config
+        if model_config is not None and '_name_or_path' in model_config:
+            card.data['base_model'] = model_config['_name_or_path']
+        lines = card.text.splitlines()
+        quantization_config = None
+        if hasattr(model_config, 'quantization_config'):
+            quantization_config = self.config.quantization_config.to_dict()
+        training_config_text = ''
+        quantization_prefix = 'The following `bitsandbytes` quantization config was used during training:'
+        if quantization_config is not None:
+            training_config_text += f'\n{quantization_prefix}\n'
+            training_config_text += '\n'.join([f'- {name}: {value}' for (name, value) in quantization_config.items()])
+            training_config_text += '\n'
+        training_procedure_heading = '## Training procedure'
+        if quantization_prefix not in lines and bool(training_config_text):
+            if training_procedure_heading in lines:
+                lines.insert(lines.index(training_procedure_heading) + 2, training_config_text)
+            else:
+                lines.append(f'{training_procedure_heading}\n{training_config_text}')
+        framework_block_heading = '### Framework versions'
+        if f'- PEFT {__version__}' not in lines:
+            if framework_block_heading in lines:
+                lines.insert(lines.index(framework_block_heading) + 2, f'- PEFT {__version__}')
+            else:
+                lines.append(f'{framework_block_heading}\n\n- PEFT {__version__}')
+        card.text = '\n'.join(lines)
+        card.save(filename)
+
+class PeftModelForSequenceClassification(PeftModel):
+
+    def __init__(self, model: torch.nn.Module, peft_config: PeftConfig, adapter_name: str='default', **kwargs) -> None:
+        super().__init__(model, peft_config, adapter_name, **kwargs)
+        classifier_module_names = ['classifier', 'score']
+        if self.modules_to_save is None:
+            self.modules_to_save = set(classifier_module_names)
+        else:
+            self.modules_to_save.update(classifier_module_names)
+        if hasattr(peft_config, 'modules_to_save'):
+            if peft_config.modules_to_save is None:
+                peft_config.modules_to_save = classifier_module_names[:]
+            else:
+                peft_config.modules_to_save.extend(classifier_module_names)
+        for (name, _) in self.base_model.named_children():
+            if any((module_name in name for module_name in self.modules_to_save)):
+                self.cls_layer_name = name
+                break
+        _set_trainable(self, adapter_name)
+
+    def add_adapter(self, adapter_name: str, peft_config: PeftConfig) -> None:
+        if hasattr(peft_config, 'modules_to_save'):
+            classifier_module_names = ['classifier', 'score']
+            if peft_config.modules_to_save is None:
+                peft_config.modules_to_save = classifier_module_names[:]
+            else:
+                peft_config.modules_to_save.extend(classifier_module_names)
+        return super().add_adapter(adapter_name, peft_config)
+
+    def forward(self, input_ids=None, attention_mask=None, inputs_embeds=None, labels=None, output_attentions=None, output_hidden_states=None, return_dict=None, task_ids=None, **kwargs):
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+        peft_config = self.active_peft_config
+        if not peft_config.is_prompt_learning:
+            with self._enable_peft_forward_hooks(**kwargs):
+                kwargs = {k: v for (k, v) in kwargs.items() if k not in self.special_peft_forward_args}
+                if peft_config.peft_type == PeftType.POLY:
+                    kwargs['task_ids'] = task_ids
+                return self.base_model(input_ids=input_ids, attention_mask=attention_mask, inputs_embeds=inputs_embeds, labels=labels, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, **kwargs)
+        batch_size = _get_batch_size(input_ids, inputs_embeds)
+        if attention_mask is not None:
+            prefix_attention_mask = torch.ones(batch_size, peft_config.num_virtual_tokens).to(attention_mask.device)
+            attention_mask = torch.cat((prefix_attention_mask, attention_mask), dim=1)
+        if kwargs.get('position_ids', None) is not None:
+            warnings.warn('Position ids are not supported for parameter efficient tuning. Ignoring position ids.')
+            kwargs['position_ids'] = None
+        kwargs.update({'attention_mask': attention_mask, 'labels': labels, 'output_attentions': output_attentions, 'output_hidden_states': output_hidden_states, 'return_dict': return_dict})
+        if peft_config.peft_type == PeftType.PREFIX_TUNING:
+            return self._prefix_tuning_forward(input_ids=input_ids, **kwargs)
+        else:
+            if kwargs.get('token_type_ids', None) is not None:
+                kwargs['token_type_ids'] = torch.cat((torch.zeros(batch_size, peft_config.num_virtual_tokens).to(self.word_embeddings.weight.device), kwargs['token_type_ids']), dim=1).long()
+            if inputs_embeds is None:
+                inputs_embeds = self.word_embeddings(input_ids)
+            prompts = self.get_prompt(batch_size=batch_size, task_ids=task_ids)
+            prompts = prompts.to(inputs_embeds.dtype)
+            inputs_embeds = torch.cat((prompts, inputs_embeds), dim=1)
+            return self.base_model(inputs_embeds=inputs_embeds, **kwargs)
+
+    def _prefix_tuning_forward(self, input_ids=None, attention_mask=None, inputs_embeds=None, labels=None, output_attentions=None, output_hidden_states=None, return_dict=None, **kwargs):
+        batch_size = _get_batch_size(input_ids, inputs_embeds)
+        past_key_values = self.get_prompt(batch_size)
+        fwd_params = list(inspect.signature(self.base_model.forward).parameters.keys())
+        kwargs.update({'input_ids': input_ids, 'attention_mask': attention_mask, 'inputs_embeds': inputs_embeds, 'output_attentions': output_attentions, 'output_hidden_states': output_hidden_states, 'return_dict': return_dict, 'past_key_values': past_key_values})
+        if 'past_key_values' in fwd_params:
+            return self.base_model(labels=labels, **kwargs)
+        else:
+            transformer_backbone_name = self.base_model.get_submodule(self.transformer_backbone_name)
+            fwd_params = list(inspect.signature(transformer_backbone_name.forward).parameters.keys())
+            if 'past_key_values' not in fwd_params:
+                raise ValueError('Model does not support past key values which are required for prefix tuning.')
+            outputs = transformer_backbone_name(**kwargs)
+            pooled_output = outputs[1] if len(outputs) > 1 else outputs[0]
+            if 'dropout' in [name for (name, _) in list(self.base_model.named_children())]:
+                pooled_output = self.base_model.dropout(pooled_output)
+            logits = self.base_model.get_submodule(self.cls_layer_name)(pooled_output)
+            loss = None
+            if labels is not None:
+                if self.config.problem_type is None:
+                    if self.base_model.num_labels == 1:
+                        self.config.problem_type = 'regression'
+                    elif self.base_model.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
+                        self.config.problem_type = 'single_label_classification'
+                    else:
+                        self.config.problem_type = 'multi_label_classification'
+                if self.config.problem_type == 'regression':
+                    loss_fct = MSELoss()
+                    if self.base_model.num_labels == 1:
+                        loss = loss_fct(logits.squeeze(), labels.squeeze())
+                    else:
+                        loss = loss_fct(logits, labels)
+                elif self.config.problem_type == 'single_label_classification':
+                    loss_fct = CrossEntropyLoss()
+                    loss = loss_fct(logits.view(-1, self.base_model.num_labels), labels.view(-1))
+                elif self.config.problem_type == 'multi_label_classification':
+                    loss_fct = BCEWithLogitsLoss()
+                    loss = loss_fct(logits, labels)
+            if not return_dict:
+                output = (logits,) + outputs[2:]
+                return (loss,) + output if loss is not None else output
+            return SequenceClassifierOutput(loss=loss, logits=logits, hidden_states=outputs.hidden_states, attentions=outputs.attentions)
+
+class PeftModelForCausalLM(PeftModel):
+
+    def __init__(self, model: torch.nn.Module, peft_config: PeftConfig, adapter_name: str='default', **kwargs) -> None:
+        super().__init__(model, peft_config, adapter_name, **kwargs)
+        self.base_model_prepare_inputs_for_generation = self.base_model.prepare_inputs_for_generation
+
+    def forward(self, input_ids=None, attention_mask=None, inputs_embeds=None, labels=None, output_attentions=None, output_hidden_states=None, return_dict=None, task_ids=None, **kwargs):
+        peft_config = self.active_peft_config
+        if not peft_config.is_prompt_learning:
+            if self.base_model.config.model_type == 'mpt':
+                if inputs_embeds is not None:
+                    raise AssertionError('forward in MPTForCausalLM does not support inputs_embeds')
+                return self.base_model(input_ids=input_ids, attention_mask=attention_mask, labels=labels, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, **kwargs)
+            if peft_config.peft_type == PeftType.POLY:
+                kwargs['task_ids'] = task_ids
+            with self._enable_peft_forward_hooks(**kwargs):
+                kwargs = {k: v for (k, v) in kwargs.items() if k not in self.special_peft_forward_args}
+                return self.base_model(input_ids=input_ids, attention_mask=attention_mask, inputs_embeds=inputs_embeds, labels=labels, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, **kwargs)
+        batch_size = _get_batch_size(input_ids, inputs_embeds)
+        if attention_mask is not None:
+            prefix_attention_mask = torch.ones(batch_size, peft_config.num_virtual_tokens).to(attention_mask.device)
+            attention_mask = torch.cat((prefix_attention_mask, attention_mask), dim=1)
+        if kwargs.get('position_ids', None) is not None:
+            warnings.warn('Position ids are not supported for parameter efficient tuning. Ignoring position ids.')
+            kwargs['position_ids'] = None
+        if kwargs.get('token_type_ids', None) is not None:
+            warnings.warn('Token type ids are not supported for parameter efficient tuning. Ignoring token type ids')
+            kwargs['token_type_ids'] = None
+        kwargs.update({'attention_mask': attention_mask, 'labels': labels, 'output_attentions': output_attentions, 'output_hidden_states': output_hidden_states, 'return_dict': return_dict})
+        if peft_config.peft_type == PeftType.PREFIX_TUNING:
+            kwargs['past_key_values'] = self.get_prompt(batch_size)
+            return self.base_model(input_ids=input_ids, inputs_embeds=inputs_embeds, **kwargs)
+        else:
+            if inputs_embeds is None:
+                inputs_embeds = self.word_embeddings(input_ids)
+            if labels is not None:
+                prefix_labels = torch.full((batch_size, peft_config.num_virtual_tokens), -100).to(labels.device)
+                kwargs['labels'] = torch.cat((prefix_labels, labels), dim=1)
+            prompts = self.get_prompt(batch_size=batch_size, task_ids=task_ids)
+            prompts = prompts.to(inputs_embeds.dtype)
+            inputs_embeds = torch.cat((prompts, inputs_embeds), dim=1)
+            return self.base_model(inputs_embeds=inputs_embeds, **kwargs)
+
+    def generate(self, *args, **kwargs):
+        peft_config = self.active_peft_config
+        self.base_model.prepare_inputs_for_generation = self.prepare_inputs_for_generation
+        if hasattr(self.base_model, 'model'):
+            self.base_model.model.generation_config = self.generation_config
+        else:
+            self.base_model.generation_config = self.generation_config
+        try:
+            if not peft_config.is_prompt_learning:
+                with self._enable_peft_forward_hooks(*args, **kwargs):
+                    kwargs = {k: v for (k, v) in kwargs.items() if k not in self.special_peft_forward_args}
+                    outputs = self.base_model.generate(*args, **kwargs)
+            else:
+                outputs = self.base_model.generate(**kwargs)
+        except:
+            self.base_model.prepare_inputs_for_generation = self.base_model_prepare_inputs_for_generation
+            raise
+        else:
+            self.base_model.prepare_inputs_for_generation = self.base_model_prepare_inputs_for_generation
+            return outputs
+
+    def prepare_inputs_for_generation(self, *args, task_ids: Optional[torch.Tensor]=None, **kwargs):
+        peft_config = self.active_peft_config
+        model_kwargs = self.base_model_prepare_inputs_for_generation(*args, **kwargs)
+        uses_transformers_4_38 = packaging.version.parse(transformers.__version__) >= packaging.version.parse('4.38.0')
+        uses_transformers_4_36 = packaging.version.parse(transformers.__version__) >= packaging.version.parse('4.36.0')
+        transformers_new_cache_archs = ['llama', 'mistral', 'persimmon', 'phi']
+        if packaging.version.parse(transformers.__version__) > packaging.version.parse('4.43.3'):
+            transformers_new_cache_archs.append('bloom')
+        uses_cache = uses_transformers_4_38 or (uses_transformers_4_36 and self.base_model.config.model_type in transformers_new_cache_archs)
+        if peft_config.peft_type == PeftType.POLY:
+            model_kwargs['task_ids'] = task_ids
+        if peft_config.is_prompt_learning:
+            if uses_cache and model_kwargs['past_key_values'] is not None:
+                past_key_values = model_kwargs['past_key_values']
+                if isinstance(past_key_values, (tuple, list)):
+                    seq_len = past_key_values[0][0].shape[-2]
+                else:
+                    seq_len = past_key_values.get_seq_length()
+                if seq_len >= model_kwargs['input_ids'].shape[1]:
+                    model_kwargs['input_ids'] = model_kwargs['input_ids'][:, -1:]
+            if model_kwargs.get('attention_mask', None) is not None:
+                size = (model_kwargs['input_ids'].shape[0], peft_config.num_virtual_tokens)
+                prefix_attention_mask = torch.ones(size).to(model_kwargs['input_ids'].device)
+                model_kwargs['attention_mask'] = torch.cat((prefix_attention_mask, model_kwargs['attention_mask']), dim=1)
+            if model_kwargs.get('position_ids', None) is not None:
+                warnings.warn('Position ids are not supported for parameter efficient tuning. Ignoring position ids.')
+                model_kwargs['position_ids'] = None
+            if kwargs.get('token_type_ids', None) is not None:
+                warnings.warn('Token type ids are not supported for parameter efficient tuning. Ignoring token type ids')
+                kwargs['token_type_ids'] = None
+            requires_prompt_injection = model_kwargs['past_key_values'] is None or (isinstance(model_kwargs['past_key_values'], transformers.Cache) and (not model_kwargs['past_key_values']))
+            if requires_prompt_injection and peft_config.peft_type == PeftType.PREFIX_TUNING:
+                new_past_key_values = self.get_prompt(batch_size=model_kwargs['input_ids'].shape[0])
+                model_kwargs['past_key_values'] = new_past_key_values
+            elif requires_prompt_injection:
+                inputs_embeds = self.word_embeddings(model_kwargs['input_ids'])
+                prompts = self.get_prompt(batch_size=model_kwargs['input_ids'].shape[0], task_ids=task_ids)
+                prompts = prompts.to(inputs_embeds.dtype)
+                model_kwargs['inputs_embeds'] = torch.cat((prompts, inputs_embeds), dim=1)
+                model_kwargs['input_ids'] = None
+        _ = model_kwargs.pop('cache_position', None)
+        return model_kwargs
+
+class PeftModelForSeq2SeqLM(PeftModel):
+
+    def __init__(self, model: torch.nn.Module, peft_config: PeftConfig, adapter_name: str='default', **kwargs) -> None:
+        super().__init__(model, peft_config, adapter_name, **kwargs)
+        self.base_model_prepare_inputs_for_generation = self.base_model.prepare_inputs_for_generation
+        self.base_model_prepare_encoder_decoder_kwargs_for_generation = self.base_model._prepare_encoder_decoder_kwargs_for_generation
+
+    def forward(self, input_ids=None, attention_mask=None, inputs_embeds=None, decoder_input_ids=None, decoder_attention_mask=None, decoder_inputs_embeds=None, labels=None, output_attentions=None, output_hidden_states=None, return_dict=None, task_ids=None, **kwargs):
+        peft_config = self.active_peft_config
+        if not peft_config.is_prompt_learning:
+            if peft_config.peft_type == PeftType.POLY:
+                kwargs['task_ids'] = task_ids
+            with self._enable_peft_forward_hooks(**kwargs):
+                kwargs = {k: v for (k, v) in kwargs.items() if k not in self.special_peft_forward_args}
+                return self.base_model(input_ids=input_ids, attention_mask=attention_mask, inputs_embeds=inputs_embeds, decoder_input_ids=decoder_input_ids, decoder_attention_mask=decoder_attention_mask, decoder_inputs_embeds=decoder_inputs_embeds, labels=labels, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, **kwargs)
+        batch_size = _get_batch_size(input_ids, inputs_embeds)
+        if decoder_attention_mask is not None:
+            prefix_attention_mask = torch.ones(batch_size, peft_config.num_virtual_tokens).to(decoder_attention_mask.device)
+            if peft_config.peft_type not in [PeftType.PROMPT_TUNING, PeftType.P_TUNING]:
+                decoder_attention_mask = torch.cat((prefix_attention_mask, decoder_attention_mask), dim=1)
+        if kwargs.get('position_ids', None) is not None:
+            warnings.warn('Position ids are not supported for parameter efficient tuning. Ignoring position ids.')
+            kwargs['position_ids'] = None
+        if kwargs.get('token_type_ids', None) is not None:
+            warnings.warn('Token type ids are not supported for parameter efficient tuning. Ignoring token type ids')
+            kwargs['token_type_ids'] = None
+        kwargs.update({'attention_mask': attention_mask, 'decoder_attention_mask': decoder_attention_mask, 'labels': labels, 'output_attentions': output_attentions, 'output_hidden_states': output_hidden_states, 'return_dict': return_dict})
+        if peft_config.peft_type == PeftType.PREFIX_TUNING:
+            kwargs['past_key_values'] = self.get_prompt(batch_size)
+            return self.base_model(input_ids=input_ids, decoder_input_ids=decoder_input_ids, decoder_inputs_embeds=decoder_inputs_embeds, **kwargs)
+        elif peft_config.peft_type in [PeftType.PROMPT_TUNING, PeftType.P_TUNING]:
+            if inputs_embeds is None:
+                inputs_embeds = self.word_embeddings(input_ids)
+            if attention_mask is not None:
+                prefix_attention_mask = torch.ones(batch_size, peft_config.num_virtual_tokens).to(attention_mask.device)
+                kwargs['attention_mask'] = torch.cat((prefix_attention_mask, attention_mask), dim=1)
+            prompts = self.get_prompt(batch_size=batch_size)
+            prompts = prompts.to(inputs_embeds.dtype)
+            inputs_embeds = torch.cat((prompts[:, :peft_config.num_virtual_tokens], inputs_embeds), dim=1)
+            return self.base_model(inputs_embeds=inputs_embeds, decoder_input_ids=decoder_input_ids, decoder_inputs_embeds=decoder_inputs_embeds, **kwargs)
+        else:
+            if inputs_embeds is None:
+                inputs_embeds = self.word_embeddings(input_ids)
+            if decoder_inputs_embeds is None and decoder_input_ids is None:
+                decoder_input_ids = shift_tokens_right(labels, self.config.pad_token_id, self.config.decoder_start_token_id)
+                decoder_inputs_embeds = self.word_embeddings(decoder_input_ids)
+            if attention_mask is not None:
+                prefix_attention_mask = torch.ones(batch_size, peft_config.num_virtual_tokens).to(attention_mask.device)
+                kwargs['attention_mask'] = torch.cat((prefix_attention_mask, attention_mask), dim=1)
+            if labels is not None:
+                if peft_config.num_transformer_submodules == 1:
+                    kwargs['labels'] = labels
+                elif peft_config.num_transformer_submodules == 2:
+                    prefix_labels = torch.full((batch_size, peft_config.num_virtual_tokens), -100).to(labels.device)
+                    kwargs['labels'] = torch.cat((prefix_labels, labels), dim=1)
+            prompts = self.get_prompt(batch_size=batch_size, task_ids=task_ids)
+            prompts = prompts.to(inputs_embeds.dtype)
+            inputs_embeds = torch.cat((prompts[:, :peft_config.num_virtual_tokens], inputs_embeds), dim=1)
+            if peft_config.num_transformer_submodules == 1:
+                return self.base_model(inputs_embeds=inputs_embeds, **kwargs)
+            elif peft_config.num_transformer_submodules == 2:
+                decoder_inputs_embeds = torch.cat((prompts[:, peft_config.num_virtual_tokens:], decoder_inputs_embeds), dim=1)
+                return self.base_model(inputs_embeds=inputs_embeds, decoder_inputs_embeds=decoder_inputs_embeds, **kwargs)
+
+    def generate(self, **kwargs):
+        peft_config = self.active_peft_config
+        self.base_model.prepare_inputs_for_generation = self.prepare_inputs_for_generation
+        self.base_model._prepare_encoder_decoder_kwargs_for_generation = self._prepare_encoder_decoder_kwargs_for_generation
+        try:
+            if not peft_config.is_prompt_learning:
+                with self._enable_peft_forward_hooks(**kwargs):
+                    kwargs = {k: v for (k, v) in kwargs.items() if k not in self.special_peft_forward_args}
+                    outputs = self.base_model.generate(**kwargs)
+            else:
+                if 'input_ids' not in kwargs:
+                    raise ValueError('input_ids must be provided for Peft model generation')
+                if kwargs.get('position_ids', None) is not None:
+                    warnings.warn('Position ids are not supported for parameter efficient tuning. Ignoring position ids.')
+                    kwargs['position_ids'] = None
+                if kwargs.get('token_type_ids', None) is not None:
+                    warnings.warn('Token type ids are not supported for parameter efficient tuning. Ignoring token type ids')
+                    kwargs['token_type_ids'] = None
+                if peft_config.peft_type == PeftType.PREFIX_TUNING:
+                    outputs = self.base_model.generate(**kwargs)
+                elif peft_config.peft_type in [PeftType.PROMPT_TUNING, PeftType.P_TUNING, PeftType.MULTITASK_PROMPT_TUNING]:
+                    kwargs = deepcopy(kwargs)
+                    if 'encoder_outputs' in kwargs:
+                        del kwargs['encoder_outputs']
+                        warnings.warn('`encoder_outputs` should not be passed to `generate` when using prompt tuning. Ignoring it.')
+                    input_ids = kwargs.pop('input_ids')
+                    inputs_embeds = self.word_embeddings(input_ids)
+                    batch_size = inputs_embeds.shape[0]
+                    prompts = self.get_prompt(batch_size=batch_size, task_ids=kwargs.pop('task_ids', None))
+                    prompts = prompts.to(inputs_embeds.dtype)
+                    inputs_embeds = torch.cat((prompts[:, :peft_config.num_virtual_tokens], inputs_embeds), dim=1)
+                    kwargs['inputs_embeds'] = inputs_embeds
+                    if 'attention_mask' in kwargs:
+                        prefix_attention_mask = torch.ones(batch_size, peft_config.num_virtual_tokens).to(kwargs['attention_mask'].device)
+                        kwargs['attention_mask'] = torch.cat((prefix_attention_mask, kwargs['attention_mask']), dim=1)
+                    return self.base_model.generate(**kwargs)
+                else:
+                    raise NotImplementedError
+        except:
+            self.base_model.prepare_inputs_for_generation = self.base_model_prepare_inputs_for_generation
+            self.base_model._prepare_encoder_decoder_kwargs_for_generation = self.base_model_prepare_encoder_decoder_kwargs_for_generation
+            raise
+        else:
+            self.base_model.prepare_inputs_for_generation = self.base_model_prepare_inputs_for_generation
+            self.base_model._prepare_encoder_decoder_kwargs_for_generation = self.base_model_prepare_encoder_decoder_kwargs_for_generation
+            return outputs
+
+    def prepare_inputs_for_generation(self, *args, task_ids: torch.Tensor=None, **kwargs):
+        peft_config = self.active_peft_config
+        model_kwargs = self.base_model_prepare_inputs_for_generation(*args, **kwargs)
+        if peft_config.peft_type == PeftType.POLY:
+            model_kwargs['task_ids'] = task_ids
+        if model_kwargs['past_key_values'] is None and peft_config.peft_type == PeftType.PREFIX_TUNING:
+            batch_size = model_kwargs['decoder_input_ids'].shape[0]
+            past_key_values = self.get_prompt(batch_size)
+            model_kwargs['past_key_values'] = past_key_values
+        return model_kwargs
+
+class PeftModelForTokenClassification(PeftModel):
+
+    def __init__(self, model: torch.nn.Module, peft_config: PeftConfig=None, adapter_name: str='default', **kwargs) -> None:
+        super().__init__(model, peft_config, adapter_name, **kwargs)
+        classifier_module_names = ['classifier', 'score']
+        if self.modules_to_save is None:
+            self.modules_to_save = set(classifier_module_names)
+        else:
+            self.modules_to_save.update(classifier_module_names)
+        if hasattr(peft_config, 'modules_to_save'):
+            if peft_config.modules_to_save is None:
+                peft_config.modules_to_save = classifier_module_names[:]
+            else:
+                peft_config.modules_to_save.extend(classifier_module_names)
+        for (name, _) in self.base_model.named_children():
+            if any((module_name in name for module_name in self.modules_to_save)):
+                self.cls_layer_name = name
+                break
+        _set_trainable(self, adapter_name)
+
+    def add_adapter(self, adapter_name: str, peft_config: PeftConfig) -> None:
+        if hasattr(peft_config, 'modules_to_save'):
+            classifier_module_names = ['classifier', 'score']
+            if peft_config.modules_to_save is None:
+                peft_config.modules_to_save = classifier_module_names[:]
+            else:
+                peft_config.modules_to_save.extend(classifier_module_names)
+        return super().add_adapter(adapter_name, peft_config)
+
+    def forward(self, input_ids=None, attention_mask=None, inputs_embeds=None, labels=None, output_attentions=None, output_hidden_states=None, return_dict=None, task_ids=None, **kwargs):
+        peft_config = self.active_peft_config
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+        if not peft_config.is_prompt_learning:
+            with self._enable_peft_forward_hooks(**kwargs):
+                kwargs = {k: v for (k, v) in kwargs.items() if k not in self.special_peft_forward_args}
+                if peft_config.peft_type == PeftType.POLY:
+                    kwargs['task_ids'] = task_ids
+                return self.base_model(input_ids=input_ids, attention_mask=attention_mask, inputs_embeds=inputs_embeds, labels=labels, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, **kwargs)
+        batch_size = _get_batch_size(input_ids, inputs_embeds)
+        if attention_mask is not None:
+            prefix_attention_mask = torch.ones(batch_size, peft_config.num_virtual_tokens).to(attention_mask.device)
+            attention_mask = torch.cat((prefix_attention_mask, attention_mask), dim=1)
+        if kwargs.get('position_ids', None) is not None:
+            warnings.warn('Position ids are not supported for parameter efficient tuning. Ignoring position ids.')
+            kwargs['position_ids'] = None
+        kwargs.update({'attention_mask': attention_mask, 'labels': labels, 'output_attentions': output_attentions, 'output_hidden_states': output_hidden_states, 'return_dict': return_dict})
+        if peft_config.peft_type == PeftType.PREFIX_TUNING:
+            return self._prefix_tuning_forward(input_ids=input_ids, **kwargs)
+        else:
+            if kwargs.get('token_type_ids', None) is not None:
+                kwargs['token_type_ids'] = torch.cat((torch.zeros(batch_size, peft_config.num_virtual_tokens).to(self.word_embeddings.weight.device), kwargs['token_type_ids']), dim=1).long()
+            if inputs_embeds is None:
+                inputs_embeds = self.word_embeddings(input_ids)
+            prompts = self.get_prompt(batch_size=batch_size, task_ids=task_ids)
+            prompts = prompts.to(inputs_embeds.dtype)
+            inputs_embeds = torch.cat((prompts, inputs_embeds), dim=1)
+            return self.base_model(inputs_embeds=inputs_embeds, **kwargs)
+
+    def _prefix_tuning_forward(self, input_ids=None, attention_mask=None, inputs_embeds=None, labels=None, output_attentions=None, output_hidden_states=None, return_dict=None, **kwargs):
+        batch_size = _get_batch_size(input_ids, inputs_embeds)
+        past_key_values = self.get_prompt(batch_size)
+        fwd_params = list(inspect.signature(self.base_model.forward).parameters.keys())
+        kwargs.update({'input_ids': input_ids, 'attention_mask': attention_mask, 'inputs_embeds': inputs_embeds, 'output_attentions': output_attentions, 'output_hidden_states': output_hidden_states, 'return_dict': return_dict, 'past_key_values': past_key_values})
+        if 'past_key_values' in fwd_params:
+            return self.base_model(labels=labels, **kwargs)
+        else:
+            transformer_backbone_name = self.base_model.get_submodule(self.transformer_backbone_name)
+            fwd_params = list(inspect.signature(transformer_backbone_name.forward).parameters.keys())
+            if 'past_key_values' not in fwd_params:
+                raise ValueError('Model does not support past key values which are required for prefix tuning.')
+            outputs = transformer_backbone_name(**kwargs)
+            sequence_output = outputs[0]
+            if 'dropout' in [name for (name, _) in list(self.base_model.named_children())]:
+                sequence_output = self.base_model.dropout(sequence_output)
+            logits = self.base_model.get_submodule(self.cls_layer_name)(sequence_output)
+            loss = None
+            if labels is not None:
+                loss_fct = CrossEntropyLoss()
+                loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
+            if not return_dict:
+                output = (logits,) + outputs[2:]
+                return (loss,) + output if loss is not None else output
+            return TokenClassifierOutput(loss=loss, logits=logits, hidden_states=outputs.hidden_states, attentions=outputs.attentions)
+
+class PeftModelForQuestionAnswering(PeftModel):
+
+    def __init__(self, model: torch.nn.Module, peft_config: PeftConfig, adapter_name: str='default', **kwargs) -> None:
+        super().__init__(model, peft_config, adapter_name, **kwargs)
+        qa_module_names = ['qa_outputs']
+        if self.modules_to_save is None:
+            self.modules_to_save = set(qa_module_names)
+        else:
+            self.modules_to_save.update(qa_module_names)
+        if hasattr(peft_config, 'modules_to_save'):
+            if peft_config.modules_to_save is None:
+                peft_config.modules_to_save = qa_module_names[:]
+            else:
+                peft_config.modules_to_save.extend(qa_module_names)
+        for (name, _) in self.base_model.named_children():
+            if any((module_name in name for module_name in self.modules_to_save)):
+                self.cls_layer_name = name
+                break
+        _set_trainable(self, adapter_name)
+
+    def add_adapter(self, adapter_name: str, peft_config: PeftConfig) -> None:
+        if hasattr(peft_config, 'modules_to_save'):
+            qa_module_names = ['qa_outputs']
+            if peft_config.modules_to_save is None:
+                peft_config.modules_to_save = qa_module_names[:]
+            else:
+                peft_config.modules_to_save.extend(qa_module_names)
+        return super().add_adapter(adapter_name, peft_config)
+
+    def forward(self, input_ids=None, attention_mask=None, token_type_ids=None, position_ids=None, inputs_embeds=None, start_positions=None, end_positions=None, output_attentions=None, output_hidden_states=None, return_dict=None, task_ids=None, **kwargs):
+        peft_config = self.active_peft_config
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+        if not peft_config.is_prompt_learning:
+            if peft_config.peft_type == PeftType.POLY:
+                kwargs['task_ids'] = task_ids
+            with self._enable_peft_forward_hooks(**kwargs):
+                kwargs = {k: v for (k, v) in kwargs.items() if k not in self.special_peft_forward_args}
+                return self.base_model(input_ids=input_ids, attention_mask=attention_mask, inputs_embeds=inputs_embeds, start_positions=start_positions, end_positions=end_positions, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, **kwargs)
+        batch_size = _get_batch_size(input_ids, inputs_embeds)
+        if attention_mask is not None:
+            prefix_attention_mask = torch.ones(batch_size, peft_config.num_virtual_tokens).to(attention_mask.device)
+            attention_mask = torch.cat((prefix_attention_mask, attention_mask), dim=1)
+        if kwargs.get('position_ids', None) is not None:
+            warnings.warn('Position ids are not supported for parameter efficient tuning. Ignoring position ids.')
+            kwargs['position_ids'] = None
+        kwargs.update({'attention_mask': attention_mask, 'start_positions': start_positions, 'end_positions': end_positions, 'output_attentions': output_attentions, 'output_hidden_states': output_hidden_states, 'return_dict': return_dict})
+        if peft_config.peft_type == PeftType.PREFIX_TUNING:
+            return self._prefix_tuning_forward(input_ids=input_ids, **kwargs)
+        else:
+            if kwargs.get('token_type_ids', None) is not None:
+                kwargs['token_type_ids'] = torch.cat((torch.zeros(batch_size, peft_config.num_virtual_tokens).to(self.word_embeddings.weight.device), kwargs['token_type_ids']), dim=1).long()
+            if inputs_embeds is None:
+                inputs_embeds = self.word_embeddings(input_ids)
+            prompts = self.get_prompt(batch_size=batch_size)
+            prompts = prompts.to(inputs_embeds.dtype)
+            inputs_embeds = torch.cat((prompts, inputs_embeds), dim=1)
+            return self.base_model(inputs_embeds=inputs_embeds, **kwargs)
+
+    def _prefix_tuning_forward(self, input_ids=None, attention_mask=None, inputs_embeds=None, start_positions=None, end_positions=None, output_attentions=None, output_hidden_states=None, return_dict=None, **kwargs):
+        batch_size = _get_batch_size(input_ids, inputs_embeds)
+        past_key_values = self.get_prompt(batch_size)
+        fwd_params = list(inspect.signature(self.base_model.forward).parameters.keys())
+        kwargs.update({'input_ids': input_ids, 'attention_mask': attention_mask, 'inputs_embeds': inputs_embeds, 'output_attentions': output_attentions, 'output_hidden_states': output_hidden_states, 'return_dict': return_dict, 'past_key_values': past_key_values})
+        if 'past_key_values' in fwd_params:
+            return self.base_model(start_positions=start_positions, end_positions=end_positions, **kwargs)
+        else:
+            transformer_backbone_name = self.base_model.get_submodule(self.transformer_backbone_name)
+            fwd_params = list(inspect.signature(transformer_backbone_name.forward).parameters.keys())
+            if 'past_key_values' not in fwd_params:
+                raise ValueError('Model does not support past key values which are required for prefix tuning.')
+            outputs = transformer_backbone_name(**kwargs)
+            sequence_output = outputs[0]
+            if 'dropout' in [name for (name, _) in list(self.base_model.named_children())]:
+                sequence_output = self.base_model.dropout(sequence_output)
+            logits = self.base_model.get_submodule(self.cls_layer_name)(sequence_output)
+            (start_logits, end_logits) = logits.split(1, dim=-1)
+            start_logits = start_logits.squeeze(-1).contiguous()
+            end_logits = end_logits.squeeze(-1).contiguous()
+            total_loss = None
+            if start_positions is not None and end_positions is not None:
+                if len(start_positions.size()) > 1:
+                    start_positions = start_positions.squeeze(-1)
+                if len(end_positions.size()) > 1:
+                    end_positions = end_positions.squeeze(-1)
+                ignored_index = start_logits.size(1)
+                start_positions = start_positions.clamp(0, ignored_index)
+                end_positions = end_positions.clamp(0, ignored_index)
+                loss_fct = CrossEntropyLoss(ignore_index=ignored_index)
+                start_loss = loss_fct(start_logits, start_positions)
+                end_loss = loss_fct(end_logits, end_positions)
+                total_loss = (start_loss + end_loss) / 2
+            if not return_dict:
+                output = (start_logits, end_logits) + outputs[2:]
+                return (total_loss,) + output if total_loss is not None else output
+            return QuestionAnsweringModelOutput(loss=total_loss, start_logits=start_logits, end_logits=end_logits, hidden_states=outputs.hidden_states, attentions=outputs.attentions)
+
+class PeftModelForFeatureExtraction(PeftModel):
+
+    def __init__(self, model: torch.nn.Module, peft_config: PeftConfig, adapter_name: str='default', **kwargs):
+        super().__init__(model, peft_config, adapter_name, **kwargs)
+
+    def forward(self, input_ids=None, attention_mask=None, inputs_embeds=None, output_attentions=None, output_hidden_states=None, return_dict=None, task_ids=None, **kwargs):
+        peft_config = self.active_peft_config
+        if not peft_config.is_prompt_learning:
+            if peft_config.peft_type == PeftType.POLY:
+                kwargs['task_ids'] = task_ids
+            with self._enable_peft_forward_hooks(**kwargs):
+                kwargs = {k: v for (k, v) in kwargs.items() if k not in self.special_peft_forward_args}
+                return self.base_model(input_ids=input_ids, attention_mask=attention_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, **kwargs)
+        batch_size = _get_batch_size(input_ids, inputs_embeds)
+        if attention_mask is not None:
+            prefix_attention_mask = torch.ones(batch_size, peft_config.num_virtual_tokens).to(attention_mask.device)
+            attention_mask = torch.cat((prefix_attention_mask, attention_mask), dim=1)
+        if kwargs.get('position_ids', None) is not None:
+            warnings.warn('Position ids are not supported for parameter efficient tuning. Ignoring position ids.')
+            kwargs['position_ids'] = None
+        if kwargs.get('token_type_ids', None) is not None:
+            warnings.warn('Token type ids are not supported for parameter efficient tuning. Ignoring token type ids')
+            kwargs['token_type_ids'] = None
+        kwargs.update({'attention_mask': attention_mask, 'output_attentions': output_attentions, 'output_hidden_states': output_hidden_states, 'return_dict': return_dict})
+        if peft_config.peft_type == PeftType.PREFIX_TUNING:
+            kwargs['past_key_values'] = self.get_prompt(batch_size)
+            return self.base_model(input_ids=input_ids, **kwargs)
+        else:
+            if inputs_embeds is None:
+                inputs_embeds = self.word_embeddings(input_ids)
+            prompts = self.get_prompt(batch_size=batch_size)
+            prompts = prompts.to(inputs_embeds.dtype)
+            inputs_embeds = torch.cat((prompts, inputs_embeds), dim=1)
+            return self.base_model(inputs_embeds=inputs_embeds, **kwargs)
+
+@dataclass
+class TunerLayerStatus:
+    name: str
+    module_type: str
+    enabled: bool
+    active_adapters: list[str]
+    merged_adapters: list[str]
+    requires_grad: dict[str, bool | Literal['irregular']]
+    available_adapters: list[str]
+    devices: dict[str, list[str]]
+
+def get_layer_status(model: torch.nn.Module) -> list[TunerLayerStatus]:
+    if isinstance(model, PeftModel):
+        base_model = model.base_model
+        if not isinstance(base_model, BaseTuner):
+            raise TypeError('get_layer_status() got an invalid PeftModel instance; prefix tuning and adaption prompt are not supported.')
+    else:
+        base_model = model
+    layer_status: list[TunerLayerStatus] = []
+    for (name, module) in base_model.named_modules():
+        if not isinstance(module, BaseTunerLayer):
+            continue
+        mapping_requires_grad_list: dict[str, list[bool]] = collections.defaultdict(list)
+        for adapter_module_name in module.adapter_layer_names:
+            adapter_module = getattr(module, adapter_module_name)
+            if isinstance(adapter_module, torch.nn.ModuleDict):
+                for (key, submodule) in adapter_module.items():
+                    for param in submodule.parameters():
+                        mapping_requires_grad_list[key].append(param.requires_grad)
+            elif isinstance(adapter_module, torch.nn.ParameterDict):
+                for (key, param) in adapter_module.items():
+                    mapping_requires_grad_list[key].append(param.requires_grad)
+            else:
+                pass
+
+        def check_irrgular(vals: list[bool]) -> bool | Literal['irregular']:
+            if all(vals):
+                return True
+            if not any(vals):
+                return False
+            return 'irregular'
+        requires_grad = {key: check_irrgular(vals) for (key, vals) in mapping_requires_grad_list.items()}
+        devices_dd = collections.defaultdict(list)
+        for adapter_module_name in module.adapter_layer_names + module.other_param_names:
+            adapter_module = getattr(module, adapter_module_name)
+            if isinstance(adapter_module, torch.nn.ModuleDict):
+                for (key, submodule) in adapter_module.items():
+                    devices_dd[key].extend([param.device.type for param in submodule.parameters()])
+            elif isinstance(adapter_module, torch.nn.ParameterDict) or adapter_module.__class__.__name__ == 'BufferDict':
+                for (key, param) in adapter_module.items():
+                    devices_dd[key].append(param.device.type)
+        devices = {key: sorted(set(val)) for (key, val) in devices_dd.items()}
+        status = TunerLayerStatus(name=name, module_type=repr(module).partition('(')[0], enabled=not module.disable_adapters, active_adapters=module.active_adapters, merged_adapters=module.merged_adapters, requires_grad=requires_grad, available_adapters=sorted(module._get_available_adapters()), devices=devices)
+        layer_status.append(status)
+    if not layer_status:
+        raise ValueError("No adapter layers found in the model, please ensure that it's a PEFT model or that you have PEFT adapters injected in the model.")
+    return layer_status
+
+@dataclass
+class TunerModelStatus:
+    base_model_type: str
+    adapter_model_type: str
+    peft_types: dict[str, str]
+    trainable_params: int
+    total_params: int
+    num_adapter_layers: int
+    enabled: bool | Literal['irregular']
+    active_adapters: list[str] | Literal['irregular']
+    merged_adapters: list[str] | Literal['irregular']
+    requires_grad: dict[str, bool | Literal['irregular']]
+    available_adapters: list[str]
+    devices: dict[str, list[str]]
+
+def get_model_status(model: torch.nn.Module) -> TunerModelStatus:
+    if isinstance(model, PeftModel):
+        if not isinstance(model.base_model, BaseTuner):
+            raise TypeError('get_model_status() got an invalid PeftModel instance; prefix tuning and adaption prompt are not supported.')
+        base_model_type = model.get_base_model().__class__.__name__
+        (trainable_params, total_params) = model.get_nb_trainable_parameters()
+        base_model = model.base_model
+        peft_types = {key: str(config.peft_type).partition('.')[-1] for (key, config) in base_model.peft_config.items()}
+        adapter_model_type = base_model.__class__.__name__
+    elif isinstance(model, PreTrainedModel):
+        base_model_type = model.__class__.__name__
+        (trainable_params, total_params) = PeftModel.get_nb_trainable_parameters(model)
+        base_model = model
+        peft_types = {}
+        adapter_model_type = 'None'
+    else:
+        base_model_type = 'other'
+        (trainable_params, total_params) = PeftModel.get_nb_trainable_parameters(model)
+        base_model = model
+        peft_types = {}
+        adapter_model_type = 'None'
+    layer_status = get_layer_status(model)
+    num_adapter_layers = len(layer_status)
+    enabled_set: set[bool] = {status.enabled for status in layer_status}
+    enabled: bool | Literal['irregular']
+    if len(enabled_set) == 1:
+        enabled = enabled_set.pop()
+    else:
+        enabled = 'irregular'
+    available_adapters: list[str] = sorted(set().union(*(status.available_adapters for status in layer_status)))
+    all_active_adapters: set[tuple[str, ...]] = {tuple(status.active_adapters) for status in layer_status}
+    active_adapters: list[str] | Literal['irregular']
+    if not all_active_adapters:
+        active_adapters = []
+    elif len(all_active_adapters) == 1:
+        active_adapters = list(all_active_adapters.pop())
+    else:
+        active_adapters = 'irregular'
+    merged_all: set[str] = set()
+    for status in layer_status:
+        merged_all.update(status.merged_adapters)
+    merged_adapters: list[str] | Literal['irregular'] = sorted(merged_all)
+    for status in layer_status:
+        unmerged = set(status.available_adapters) - set(status.merged_adapters)
+        if unmerged & merged_all:
+            merged_adapters = 'irregular'
+            break
+    requires_grad_all: dict[str, list[bool | Literal['irregular']]] = collections.defaultdict(list)
+    for status in layer_status:
+        for (key, val) in status.requires_grad.items():
+            requires_grad_all[key].append(val)
+
+    def check_irrgular(vals: list[bool | Literal['irregular']]) -> bool | Literal['irregular']:
+        if all((val is True for val in vals)):
+            return True
+        if all((val is False for val in vals)):
+            return False
+        return 'irregular'
+    requires_grad = {key: check_irrgular(vals) for (key, vals) in requires_grad_all.items()}
+    devices_dd = collections.defaultdict(list)
+    for status in layer_status:
+        for (key, val) in status.devices.items():
+            devices_dd[key].extend(val)
+    devices = {key: sorted(set(val)) for (key, val) in devices_dd.items()}
+    adapter_model_status = TunerModelStatus(base_model_type=base_model_type, adapter_model_type=adapter_model_type, peft_types=peft_types, trainable_params=trainable_params, total_params=total_params, num_adapter_layers=num_adapter_layers, enabled=enabled, active_adapters=active_adapters, merged_adapters=merged_adapters, requires_grad=requires_grad, available_adapters=available_adapters, devices=devices)
+    return adapter_model_status
+
+# File: peft-main/src/peft/tuners/__init__.py
+from .adaption_prompt import AdaptionPromptConfig, AdaptionPromptModel
+from .lora import LoraConfig, LoraModel, LoftQConfig, LoraRuntimeConfig
+from .loha import LoHaConfig, LoHaModel
+from .lokr import LoKrConfig, LoKrModel
+from .ia3 import IA3Config, IA3Model
+from .adalora import AdaLoraConfig, AdaLoraModel
+from .boft import BOFTConfig, BOFTModel
+from .p_tuning import PromptEncoder, PromptEncoderConfig, PromptEncoderReparameterizationType
+from .prefix_tuning import PrefixEncoder, PrefixTuningConfig
+from .prompt_tuning import PromptEmbedding, PromptTuningConfig, PromptTuningInit
+from .multitask_prompt_tuning import MultitaskPromptEmbedding, MultitaskPromptTuningConfig, MultitaskPromptTuningInit
+from .oft import OFTConfig, OFTModel
+from .mixed import MixedModel
+from .poly import PolyConfig, PolyModel
+from .ln_tuning import LNTuningConfig, LNTuningModel
+from .vera import VeraConfig, VeraModel
+from .fourierft import FourierFTConfig, FourierFTModel
+from .xlora import XLoraConfig, XLoraModel
+from .hra import HRAConfig, HRAModel
+from .vblora import VBLoRAConfig, VBLoRAModel
+
+# File: peft-main/src/peft/tuners/_buffer_dict.py
+from __future__ import annotations
+import collections
+from collections import OrderedDict
+import torch
+from torch.nn import Module
+
+class BufferDict(Module):
+
+    def __init__(self, buffers=None, persistent: bool=False):
+        super().__init__()
+        if buffers is not None:
+            self.update(buffers)
+        self.persistent = persistent
+
+    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):
+        self._buffers.clear()
+
+    def pop(self, key):
+        v = self[key]
+        del self[key]
+        return v
+
+    def keys(self):
+        return self._buffers.keys()
+
+    def items(self):
+        return self._buffers.items()
+
+    def values(self):
+        return self._buffers.values()
+
+    def update(self, buffers):
+        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, collections.abc.Mapping):
+            if isinstance(buffers, (OrderedDict, BufferDict)):
+                for (key, buffer) in buffers.items():
+                    self[key] = buffer
+            else:
+                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_str = '' if not p.is_cuda else f' (GPU {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.')
+
+# File: peft-main/src/peft/tuners/adalora/__init__.py
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available
+from .config import AdaLoraConfig
+from .gptq import SVDQuantLinear
+from .layer import AdaLoraLayer, RankAllocator, SVDLinear
+from .model import AdaLoraModel
+__all__ = ['AdaLoraConfig', 'AdaLoraLayer', 'AdaLoraModel', 'SVDLinear', 'RankAllocator', 'SVDQuantLinear']
+
+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}')
+
+# File: peft-main/src/peft/tuners/adalora/bnb.py
+from typing import Any
+import torch
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available
+from .layer import AdaLoraLayer
+if is_bnb_available():
+
+    class SVDLinear8bitLt(torch.nn.Module, AdaLoraLayer):
+
+        def __init__(self, base_layer: torch.nn.Module, adapter_name: str, r: int=0, lora_alpha: int=1, lora_dropout: float=0.0, init_lora_weights: bool=True, **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, lora_dropout, init_lora_weights)
+
+        def forward(self, x: torch.Tensor) -> torch.Tensor:
+            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-05
+                output = dropout(x) @ (lora_A * lora_E).T @ lora_B.T
+                if requires_conversion:
+                    output = output.to(expected_dtype)
+                output = output * scaling / ranknum
+                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):
+
+        def __init__(self, base_layer: torch.nn.Module, adapter_name: str, r: int=0, lora_alpha: int=1, lora_dropout: float=0.0, init_lora_weights: bool=True, **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, lora_dropout, init_lora_weights)
+
+        def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+            result = self.base_layer(x, *args, **kwargs)
+            if self.disable_adapters:
+                return result
+            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-05
+                requires_conversion = not torch.is_autocast_enabled()
+                if requires_conversion:
+                    expected_dtype = result.dtype
+                    compute_dtype = lora_A.dtype
+                    if x.dtype != compute_dtype:
+                        x = x.to(compute_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
+
+# File: peft-main/src/peft/tuners/adalora/config.py
+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):
+    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):
+        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
+        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.')
+        if isinstance(self.target_modules, str) and self.layers_pattern is not None:
+            raise ValueError('`layers_pattern` cannot be used when `target_modules` is a str.')
+        if self.r != 8:
+            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.')
+
+# File: peft-main/src/peft/tuners/adalora/gptq.py
+import torch
+from .layer import AdaLoraLayer
+
+class SVDQuantLinear(torch.nn.Module, AdaLoraLayer):
+
+    def __init__(self, base_layer, adapter_name, r: int=0, lora_alpha: int=1, lora_dropout: float=0.0, init_lora_weights: bool=True, **kwargs) -> None:
+        super().__init__()
+        AdaLoraLayer.__init__(self, base_layer)
+        self.quant_linear_module = base_layer
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, lora_alpha, lora_dropout, init_lora_weights)
+
+    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-05
+            requires_conversion = not torch.is_autocast_enabled()
+            if requires_conversion:
+                expected_dtype = result.dtype
+                if x.dtype != torch.float32:
+                    x = x.float()
+            output = dropout(x) @ (lora_A * lora_E).T @ lora_B.T * scaling / ranknum
+            if requires_conversion:
+                output = output.to(expected_dtype)
+            result += output
+        return result
+
+        def __repr__(self) -> str:
+            rep = super().__repr__()
+            return 'adalora.' + rep
+
+# File: peft-main/src/peft/tuners/adalora/layer.py
+import warnings
+from typing import Any, List, 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
+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):
+    adapter_layer_names = ('lora_A', 'lora_B', 'lora_E', 'lora_embedding_A', 'lora_embedding_B')
+    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, r, lora_alpha, lora_dropout, init_lora_weights):
+        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
+        self.lora_A[adapter_name] = nn.Parameter(torch.randn(r, self.in_features))
+        self.lora_E[adapter_name] = nn.Parameter(torch.randn(r, 1))
+        self.lora_B[adapter_name] = nn.Parameter(torch.randn(self.out_features, r))
+        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)
+
+    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):
+
+    def __init__(self, base_layer: nn.Module, adapter_name: str, r: int=0, lora_alpha: int=1, lora_dropout: float=0.0, fan_in_fan_out: bool=False, init_lora_weights: bool=True, **kwargs) -> None:
+        super().__init__()
+        AdaLoraLayer.__init__(self, base_layer)
+        self.get_base_layer().weight.requires_grad = False
+        self.fan_in_fan_out = fan_in_fan_out
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, lora_alpha, lora_dropout, init_lora_weights)
+
+    def merge(self, safe_merge: bool=False, adapter_names: Optional[List[str]]=None) -> 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:
+        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-05)
+
+    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-05
+                x = x.to(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 RankAllocator:
+
+    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)
+        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
+        if step <= tinit:
+            budget = self.init_bgt
+            mask_ind = False
+        elif step > total_step - tfinal:
+            budget = self.target_bgt
+            mask_ind = True
+        else:
+            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 = True if step % self.peft_config.deltaT == 0 else False
+        return (budget, mask_ind)
+
+    def update_ipt(self, model):
+        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()
+                    self.exp_avg_ipt[n] = self.beta1 * self.exp_avg_ipt[n] + (1 - self.beta1) * self.ipt[n]
+                    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 = {}
+        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 = []
+        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))
+        mask_threshold = torch.kthvalue(torch.cat(all_score), k=self.init_bgt - budget)[0].item()
+        rank_pattern = {}
+        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):
+        if global_step < self.peft_config.total_step - self.peft_config.tfinal:
+            self.update_ipt(model)
+        (budget, mask_ind) = self.budget_schedule(global_step)
+        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):
+        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)
+
+# File: peft-main/src/peft/tuners/adalora/model.py
+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
+from peft.utils import TRANSFORMERS_MODELS_TO_ADALORA_TARGET_MODULES_MAPPING, _freeze_adapter, _get_submodules, get_auto_gptq_quant_linear, get_quantization_config
+from peft.utils.integrations import gather_params_ctx
+from .gptq import SVDQuantLinear
+from .layer import AdaLoraLayer, RankAllocator, SVDLinear
+
+class AdaLoraModel(LoraModel):
+
+    def __init__(self, model, config, adapter_name):
+        super().__init__(model, config, adapter_name)
+        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('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:
+        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, 'lora_dropout': lora_config.lora_dropout, 'fan_in_fan_out': lora_config.fan_in_fan_out, 'init_lora_weights': lora_config.init_lora_weights, '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 not isinstance(target, AdaLoraLayer):
+            new_module = self._create_new_module(lora_config, adapter_name, target, **kwargs)
+            if adapter_name not in self.active_adapters:
+                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, lora_config.lora_dropout, lora_config.init_lora_weights)
+
+    @staticmethod
+    def _create_new_module(lora_config, adapter_name, target, **kwargs):
+        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)
+        AutoGPTQQuantLinear = get_auto_gptq_quant_linear(gptq_quantization_config)
+        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, 'memory_efficient_backward': target_base_layer.state.memory_efficient_backward, 'threshold': target_base_layer.state.threshold, 'index': target_base_layer.index})
+            new_module = SVDLinear8bitLt(target, adapter_name, **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, **fourbit_kwargs)
+        elif AutoGPTQQuantLinear is not None and isinstance(target, AutoGPTQQuantLinear):
+            new_module = SVDQuantLinear(target, adapter_name, **kwargs)
+        else:
+            if isinstance(target_base_layer, torch.nn.Linear):
+                if kwargs['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.')
+                    kwargs['fan_in_fan_out'] = lora_config.fan_in_fan_out = False
+            elif isinstance(target_base_layer, Conv1D):
+                if not kwargs['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.')
+                    kwargs['fan_in_fan_out'] = lora_config.fan_in_fan_out = True
+            else:
+                raise ValueError(f'Target module {target} is not supported. Currently, only `torch.nn.Linear` and `Conv1D` are supported.')
+            new_module = SVDLinear(target, adapter_name, **kwargs)
+        return new_module
+
+    @staticmethod
+    def _prepare_adapter_config(peft_config, model_config):
+        if peft_config.target_modules is None:
+            if model_config['model_type'] not in TRANSFORMERS_MODELS_TO_ADALORA_TARGET_MODULES_MAPPING:
+                raise ValueError('Please specify `target_modules` in `peft_config`')
+            peft_config.target_modules = TRANSFORMERS_MODELS_TO_ADALORA_TARGET_MODULES_MAPPING[model_config['model_type']]
+        return peft_config
+
+    def __getattr__(self, name: str):
+        try:
+            return super().__getattr__(name)
+        except AttributeError:
+            if name == 'model':
+                raise
+            return getattr(self.model, name)
+
+    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):
+            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))
+                    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 ValueError('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, lora_config.lora_dropout, lora_config.init_lora_weights)
+            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)
+                    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):
+        lora_config = self.peft_config[self.trainable_adapter_name]
+        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
+        elif global_step == lora_config.total_step - lora_config.tfinal:
+            (_, rank_pattern) = self.rankallocator.update_and_allocate(self.model, global_step, force_mask=True)
+            lora_config.rank_pattern = rank_pattern
+            self.rankallocator.reset_ipt()
+        elif global_step > lora_config.total_step - lora_config.tfinal:
+            self.rankallocator.mask_using_rank_pattern(self.model, lora_config.rank_pattern)
+        else:
+            return None
+
+    def add_weighted_adapter(self, *args, **kwargs):
+        raise TypeError(f'{self.__class__.__name__} does not support add_weighted_adapter method.')
+
+# File: peft-main/src/peft/tuners/adaption_prompt/config.py
+from collections import namedtuple
+from dataclasses import dataclass, field
+from peft.config import PeftConfig
+from peft.utils import PeftType
+from .utils import llama_compute_query_states
+
+@dataclass
+class AdaptionPromptConfig(PeftConfig):
+    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):
+        self.peft_type = PeftType.ADAPTION_PROMPT
+
+    @property
+    def is_adaption_prompt(self) -> bool:
+        return True
+ModelTypeConfig = namedtuple('ModelTypeConfig', ['compute_query_states', 'target_modules', 'k_proj_layer', 'v_proj_layer', 'o_proj_layer'])
+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(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')}
+
+def prepare_config(peft_config: AdaptionPromptConfig, model) -> AdaptionPromptConfig:
+    if model.config.model_type not in TRANSFORMERS_MODEL_CONFIG:
+        raise ValueError("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
+
+# File: peft-main/src/peft/tuners/adaption_prompt/layer.py
+import math
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from .config import TRANSFORMERS_MODEL_CONFIG
+
+class AdaptedAttention(nn.Module):
+
+    def __init__(self, model_type: str, adapter_len: int, model):
+        assert not isinstance(model, AdaptedAttention)
+        super().__init__()
+        self.model_type = model_type
+        self.model = model
+        self.adapter_len = adapter_len
+        device = next(model.parameters()).device
+        target_dtype = model.q_proj.weight.dtype if model.q_proj.weight.dtype not in [torch.int8, torch.uint8] else torch.float32
+        self.adaption_prompt = nn.Parameter(torch.empty(1, adapter_len, self.model.hidden_size, device=device, dtype=target_dtype).normal_())
+        self.adaption_gate = nn.Parameter(torch.zeros(1, device=device, dtype=target_dtype))
+
+    def forward(self, **kwargs):
+        if kwargs.get('output_attention', False):
+            raise NotImplementedError('output_attention is not currently supported.')
+        (output, _, past_key_value) = 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
+        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)
+        adapter_k = key.view(1, self.adapter_len, self.model.num_heads // factor, self.model.head_dim).repeat(bsz, 1, 1, 1).transpose(1, 2)
+        adapter_v = value.view(1, self.adapter_len, self.model.num_heads // factor, self.model.head_dim).repeat(bsz, 1, 1, 1).transpose(1, 2)
+        adapter_k = torch.repeat_interleave(adapter_k, repeats=factor, dim=1)
+        adapter_v = torch.repeat_interleave(adapter_v, repeats=factor, dim=1)
+        compute_query_states = TRANSFORMERS_MODEL_CONFIG[self.model_type].compute_query_states
+        query_states = compute_query_states(model=self.model, **kwargs)
+        previous_dtype = query_states.dtype
+        scores = torch.matmul(query_states, adapter_k.transpose(2, 3).to(previous_dtype)) / math.sqrt(self.model.head_dim)
+        scores = self.adaption_gate * F.softmax(scores, dim=-1, dtype=torch.float32).to(previous_dtype)
+        adapter_output = torch.matmul(scores, adapter_v).transpose(1, 2).reshape(bsz, q_len, -1)
+        if o_proj_layer is not None:
+            adapter_output = getattr(self.model, o_proj_layer)(adapter_output)
+        output = output + adapter_output
+        output = output.to(previous_dtype)
+        return (output, None, past_key_value)
+
+# File: peft-main/src/peft/tuners/adaption_prompt/model.py
+from typing import Dict, List
+import torch.nn as nn
+from peft.utils import _freeze_adapter, _get_submodules
+from .config import AdaptionPromptConfig, prepare_config
+from .layer import AdaptedAttention
+from .utils import is_adaption_prompt_trainable
+
+class AdaptionPromptModel(nn.Module):
+
+    def __init__(self, model, configs: Dict, adapter_name: str):
+        super().__init__()
+        self.model = model
+        self.peft_config: Dict[str, AdaptionPromptConfig] = {}
+        self._parents: Dict[str, List[nn.Module]] = {}
+        self._cached_adapters: Dict[str, List] = {}
+        self._active_adapter = None
+        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:
+        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(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)}'.")
+        parents = parents[-config.adapter_layers:]
+        self._parents[adapter_name] = parents
+        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) -> None:
+        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):
+        self._enabled = True
+        self._set_adapted_attentions(self._active_adapter)
+
+    def disable_adapter_layers(self):
+        self._enabled = False
+        self._remove_adapted_attentions(self._active_adapter)
+
+    def _create_adapted_attentions(self, config: AdaptionPromptConfig, parents: List[nn.Module]) -> None:
+        for par in parents:
+            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:
+        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:
+        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:
+        for (n, p) in model.named_parameters():
+            if not is_adaption_prompt_trainable(n):
+                p.requires_grad = False
+
+    def __getattr__(self, name: str):
+        try:
+            return super().__getattr__(name)
+        except AttributeError:
+            if name == 'model':
+                raise
+            return getattr(self.model, name)
+
+# File: peft-main/src/peft/tuners/adaption_prompt/utils.py
+import inspect
+import torch
+import torch.nn as nn
+
+def llama_rotate_half(x: torch.Tensor) -> torch.Tensor:
+    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):
+    if len(cos.shape) == 4:
+        gather_indices = position_ids[:, None, :, None]
+        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)
+    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:
+    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()
+    query_states = model.q_proj(hidden_states).view(bsz, q_len, model.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, model.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):
+            seq_len += past_key_value[0].shape[-2]
+        else:
+            seq_len += past_key_value.get_seq_length(model.layer_idx)
+    if 'position_ids' not in inspect.signature(model.rotary_emb.forward).parameters:
+        (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:
+        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}
+    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)
+    if len(cos.shape) == 3:
+        cos = cos.unsqueeze(1)
+        sin = sin.unsqueeze(1)
+    return query_states * cos + llama_rotate_half(query_states) * sin
+
+def is_adaption_prompt_trainable(params: str) -> bool:
+    return params.split('.')[-1].startswith('adaption_')
+
+# File: peft-main/src/peft/tuners/boft/config.py
+from dataclasses import dataclass, field
+from typing import List, Optional, Union
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+@dataclass
+class BOFTConfig(PeftConfig):
+    boft_block_size: int = field(default=4, metadata={'help': 'BOFT block size across different layers.', 'note': 'You can only specify either boft_block_size or boft_block_num, but not both simultaneously, because boft_block_size x boft_block_num = layer dimension.'})
+    boft_block_num: int = field(default=0, metadata={'help': 'Number of BOFT blocks per injected layer.', 'note': 'You can only specify either boft_block_size or boft_block_num, but not both simultaneously, because boft_block_size x boft_block_num = layer dimension.'})
+    boft_n_butterfly_factor: int = field(default=1, metadata={'help': 'Number of butterfly factors.', 'note': ('for example, boft_n_butterfly_factor=2, the effective block size of OFT becomes twice as big and the number of blocks become half.', 'note: for boft_n_butterfly_factor=1, BOFT is the same as vanilla OFT.')})
+    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 BOFT.', 'example': "For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$' "})
+    boft_dropout: float = field(default=0.0, metadata={'help': 'BOFT multiplicative dropout'})
+    fan_in_fan_out: bool = field(default=False, metadata={'help': 'Set this to True if the layer to replace stores weight like (fan_in, fan_out)'})
+    bias: str = field(default='none', metadata={'help': "Bias type for BOFT. Can be 'none', 'all' or 'boft_only'"})
+    modules_to_save: Optional[List[str]] = field(default=None, metadata={'help': 'List of modules apart from BOFT layers to be set as trainable and saved in the final checkpoint. ', 'note': ('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 weights of the BOFT layers with their default initialization. Don't change ", "this setting, except if you know exactly what you're doing.")})
+    layers_to_transform: Optional[Union[List[int], int]] = field(default=None, metadata={'help': 'The layer indexes to transform, is this argument is specified, PEFT will transform only the layers indexes that are specified inside this list. If a single integer is passed, PEFT will transform only the layer at this index.'})
+    layers_pattern: Optional[str] = field(default=None, metadata={'help': 'The layer pattern name, used only if `layers_to_transform` is different to None and if the layer pattern is not in the common layers pattern.'})
+
+    def __post_init__(self):
+        self.peft_type = PeftType.BOFT
+        self.target_modules = set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        if self.boft_block_size == 0 and self.boft_block_num == 0:
+            raise ValueError('You must specify either boft_block_size or boft_block_num.')
+        if not (self.boft_block_size != 0) ^ (self.boft_block_num != 0):
+            raise ValueError(f'You can only specify either boft_block_size ({self.boft_block_size}) or boft_block_num ({self.boft_block_num}), but not both simultaneously, because boft_block_size x boft_block_num != in_features.')
+
+# File: peft-main/src/peft/tuners/boft/layer.py
+from __future__ import annotations
+import math
+import os
+import warnings
+from contextlib import contextmanager
+from typing import Any, Optional, Union
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.autograd import Function
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+_FBD_CUDA = None
+
+@contextmanager
+def patch_environment(**kwargs):
+    existing_vars = {}
+    for (key, value) in kwargs.items():
+        key = key.upper()
+        if key in os.environ:
+            existing_vars[key] = os.environ[key]
+        os.environ[key] = str(value)
+    yield
+    for key in kwargs:
+        key = key.upper()
+        if key in existing_vars:
+            os.environ[key] = existing_vars[key]
+        else:
+            os.environ.pop(key, None)
+
+def get_fbd_cuda():
+    global _FBD_CUDA
+    if _FBD_CUDA is not None:
+        return _FBD_CUDA
+    from torch.utils.cpp_extension import load
+    curr_dir = os.path.dirname(__file__)
+    try:
+        with patch_environment(CC='gcc', CXX='gcc'):
+            fbd_cuda = load(name='fbd_cuda', sources=[f'{curr_dir}/fbd/fbd_cuda.cpp', f'{curr_dir}/fbd/fbd_cuda_kernel.cu'], verbose=True)
+    except Exception as e:
+        warnings.warn(f'Failed to load the CUDA extension: {e}, check if ninja is available.')
+        warnings.warn('Setting boft_n_butterfly_factor to 1 to speed up the finetuning process.')
+        fbd_cuda = None
+    _FBD_CUDA = fbd_cuda
+    return _FBD_CUDA
+
+class FastBlockDiag(Function):
+
+    @staticmethod
+    def forward(ctx, input):
+        output = get_fbd_cuda().forward(input)[0]
+        ctx.save_for_backward(input)
+        return output
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        (input,) = ctx.saved_tensors
+        grad_input = get_fbd_cuda().backward(grad_output, input)[0]
+        return grad_input
+
+class MultiplicativeDropoutLayer(nn.Module):
+
+    def __init__(self, p=0.0):
+        super().__init__()
+        self.p = p
+
+    def forward(self, x):
+        if self.training:
+            if x.shape[-1] != x.shape[-2]:
+                raise ValueError('The last two dimensions of input should be the same!')
+            (N, D, H, _) = x.shape
+            n_random = torch.randint(0, N, (1,)).item()
+            num_to_replace = int(self.p * D)
+            num_zeros = D - num_to_replace
+            mask = torch.cat([torch.ones(num_to_replace, device=x.device), torch.zeros(num_zeros, device=x.device)])
+            mask = mask[torch.randperm(D)].view(1, D, 1, 1)
+            full_mask = torch.zeros(N, D, 1, 1, device=x.device)
+            full_mask[n_random] = mask
+            eye_matrix = torch.eye(H, device=x.device).repeat(N, D, 1, 1)
+            x = (1 - full_mask) * x + full_mask * eye_matrix
+        return x
+
+class BOFTLayer(BaseTunerLayer):
+    adapter_layer_names = ('boft_R', 'boft_s')
+    other_param_names = ('boft_block_size', 'boft_block_num', 'boft_dropout')
+
+    def __init__(self, base_layer: nn.Module, **kwargs) -> None:
+        self.base_layer = base_layer
+        self.boft_block_size = {}
+        self.boft_block_num = {}
+        self.boft_dropout = nn.ModuleDict({})
+        self.boft_R = nn.ParameterDict({})
+        self.boft_s = nn.ParameterDict({})
+        self._disable_adapters = False
+        self.merged_adapters = []
+        self.kwargs = kwargs
+        base_layer = self.get_base_layer()
+        if isinstance(base_layer, nn.Linear):
+            (in_features, out_features) = (base_layer.in_features, base_layer.out_features)
+        elif isinstance(base_layer, nn.Conv2d):
+            (in_features, out_features) = (base_layer.in_channels, base_layer.out_channels)
+        else:
+            raise ValueError(f'Unsupported layer type {type(base_layer)}')
+        self.in_features = in_features
+        self.out_features = out_features
+
+    def set_scale(self, adapter, scale):
+        if adapter not in self.scaling:
+            return
+        warnings.warn('Scaling operation for BOFT not supported! Automatically set scale to 1.')
+
+    def scale_layer(self, scale: float) -> None:
+        if scale == 1:
+            return
+        for active_adapter in self.active_adapters:
+            if active_adapter not in self.boft_R.keys():
+                continue
+            warnings.warn('Scaling operation for BOFT not supported! Automatically set scale to 1.')
+
+    def unscale_layer(self, scale=None) -> None:
+        for active_adapter in self.active_adapters:
+            if active_adapter not in self.boft_R.keys():
+                continue
+            warnings.warn('Unscaling operation for BOFT not supported! Keeping scale to 1.')
+
+    def update_layer(self, adapter_name, boft_block_size, boft_block_num, boft_n_butterfly_factor, boft_dropout, init_weights):
+        boft_n_butterfly_factor = boft_n_butterfly_factor - 1
+        if boft_n_butterfly_factor < 0:
+            raise ValueError(f'You can only specify boft_n_butterfly_factor {boft_n_butterfly_factor + 1} to be a positive integer number.')
+        if boft_dropout > 0.0:
+            boft_dropout_layer = MultiplicativeDropoutLayer(p=boft_dropout)
+        else:
+            boft_dropout_layer = nn.Identity()
+        self.boft_dropout.update(nn.ModuleDict({adapter_name: boft_dropout_layer}))
+        if boft_block_size == 0 and boft_block_num != 0:
+            if self.in_features % boft_block_num != 0:
+                raise ValueError(f'in_features ({self.in_features}) must be divisible by boft_block_num ({boft_block_num})!')
+            if boft_n_butterfly_factor != 0:
+                if boft_n_butterfly_factor > int(math.log2(boft_block_num)):
+                    raise ValueError(f'Invalid combination of boft_n_butterfly_factor ({boft_n_butterfly_factor + 1}) and boft_block_num ({boft_block_num})!')
+                if boft_block_num % 2 ** boft_n_butterfly_factor != 0:
+                    raise ValueError(f'boft_block_num ({boft_block_num}) must be a multiple of 2 raised to the power of boft_n_butterfly_factor ({boft_n_butterfly_factor + 1})!')
+            boft_block_size = int(self.in_features // boft_block_num)
+        elif boft_block_size != 0 and boft_block_num == 0:
+            if self.in_features % boft_block_size != 0:
+                raise ValueError(f'in_features ({self.in_features}) must be divisible by boft_block_size ({boft_block_size})!')
+            if boft_n_butterfly_factor != 0:
+                if self.in_features < boft_block_size * 2 ** boft_n_butterfly_factor:
+                    raise ValueError(f'Invalid combination of in_features ({self.in_features}), boft_n_butterfly_factor ({boft_n_butterfly_factor + 1}) and boft_block_size ({boft_block_size})!')
+                if self.in_features % (boft_block_size * 2 ** boft_n_butterfly_factor) != 0:
+                    raise ValueError(f'Invalid combination of in_features ({self.in_features}), boft_n_butterfly_factor ({boft_n_butterfly_factor + 1}) and boft_block_size ({boft_block_size})!')
+            boft_block_num = int(self.in_features // boft_block_size)
+        else:
+            raise ValueError(f'You can only specify either boft_block_size ({boft_block_size}) or boft_block_num ({boft_block_num}), but not both simultaneously or setting bothto be 0, because boft_block_size x boft_block_num != in_features.')
+        if boft_n_butterfly_factor != 0:
+            if boft_block_num % 2 != 0:
+                raise ValueError(f'boft_block_num ({boft_block_num}) must be an even number!')
+            if boft_block_size % 2 != 0:
+                raise ValueError(f'boft_block_size ({boft_block_size}) must be an even number!')
+        P = torch.empty((boft_n_butterfly_factor + 1, self.in_features, self.in_features))
+        for i in range(boft_n_butterfly_factor + 1):
+            perm = self.block_butterfly_perm(self.in_features, int(boft_block_num / 2 ** i), int(boft_block_size / 2), boft_n_butterfly_factor)
+            perm_mat = self.perm2mat(perm)
+            P[i] = perm_mat
+        self.register_buffer('boft_P', P, persistent=False)
+        self.boft_R[adapter_name] = nn.Parameter(torch.zeros(boft_n_butterfly_factor + 1, boft_block_num, boft_block_size, boft_block_size))
+        self.boft_s[adapter_name] = nn.Parameter(torch.ones(int(self.out_features), 1))
+        self.reset_boft_parameters(adapter_name, init_weights)
+        self.boft_block_size[adapter_name] = boft_block_size
+        self.boft_block_num[adapter_name] = boft_block_num
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters)
+
+    def reset_boft_parameters(self, adapter_name, init_weights):
+        if init_weights is False:
+            nn.init.normal_(self.boft_R[adapter_name], mean=0.0, std=0.1)
+            nn.init.normal_(self.boft_s[adapter_name], mean=1.0, std=0.1)
+            return
+        if adapter_name in self.boft_R.keys():
+            if init_weights is True:
+                nn.init.zeros_(self.boft_R[adapter_name])
+                nn.init.ones_(self.boft_s[adapter_name])
+            else:
+                raise ValueError(f'Unknown initialization init_weights={init_weights!r}')
+
+    def perm2mat(self, indices):
+        n = len(indices)
+        perm_mat = torch.zeros((n, n))
+        for (i, idx) in enumerate(indices):
+            perm_mat[i, idx] = 1
+        return perm_mat
+
+    def block_butterfly_perm(self, n, b, r=3, n_butterfly_factor=1):
+        if n_butterfly_factor == 0:
+            return torch.arange(n)
+        if b * r * 2 > n:
+            raise ValueError('Invalid number of blocks!')
+        block_size = int(n // b)
+        indices = torch.arange(n)
+
+        def sort_block(b, r):
+            step = b / r
+            initial_order = torch.arange(b)
+            sorted_order = torch.empty(b, dtype=torch.long)
+            evens = torch.arange(0, step, 2)
+            odds = torch.arange(1, step, 2)
+            sorted_seq = torch.cat((evens, odds), dim=0)
+            for (i, pos) in enumerate(sorted_seq):
+                sorted_order[int(i * r):int(i * r + r)] = initial_order[int(pos * r):int(pos * r + r)]
+            return sorted_order
+        sorted_order = sort_block(block_size, r)
+        for i in range(0, n, block_size):
+            block_end = i + block_size
+            tmp_indices = indices[i:block_end]
+            indices[i:block_end] = tmp_indices[sorted_order]
+        return indices
+
+    def cayley_batch(self, data):
+        (b, r, c) = data.shape
+        skew_mat = 0.5 * (data - data.transpose(1, 2))
+        id_mat = torch.eye(r, device=data.device).unsqueeze(0).expand(b, r, c)
+        Q = torch.linalg.solve(id_mat + skew_mat, id_mat - skew_mat, left=False)
+        return Q
+
+class Linear(nn.Module, BOFTLayer):
+
+    def __init__(self, base_layer, adapter_name: str, boft_block_size: int=8, boft_block_num: int=0, boft_n_butterfly_factor: int=0, boft_dropout: float=0.1, fan_in_fan_out: bool=False, init_weights: Union[bool, str]=True, is_target_conv_1d_layer: bool=False, **kwargs) -> None:
+        super().__init__()
+        BOFTLayer.__init__(self, base_layer, **kwargs)
+        self.fan_in_fan_out = fan_in_fan_out
+        self._active_adapter = adapter_name
+        if not get_fbd_cuda():
+            self.fbd_cuda_available = False
+            boft_n_butterfly_factor = 1
+        else:
+            self.fbd_cuda_available = True
+        self.update_layer(adapter_name, boft_block_size, boft_block_num, boft_n_butterfly_factor, boft_dropout, init_weights)
+        self.is_target_conv_1d_layer = is_target_conv_1d_layer
+
+    def merge(self, safe_merge: bool=False, adapter_names: Optional[list[str]]=None) -> None:
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            return
+        for active_adapter in adapter_names:
+            if active_adapter in self.boft_R.keys():
+                base_layer = self.get_base_layer()
+                if safe_merge:
+                    orig_weight = base_layer.weight.data.clone()
+                    (butterfly_oft_mat, boft_s) = self.get_delta_weight(active_adapter)
+                    orig_weight = torch.transpose(orig_weight, 0, 1)
+                    orig_weight = torch.mm(butterfly_oft_mat, orig_weight)
+                    orig_weight = torch.transpose(orig_weight, 0, 1)
+                    orig_weight = orig_weight * boft_s
+                    if not torch.isfinite(orig_weight).all():
+                        raise ValueError(f'NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken')
+                    self.base_layer.weight.data = orig_weight.contiguous()
+                else:
+                    (butterfly_oft_mat, boft_s) = self.get_delta_weight(active_adapter)
+                    orig_weight = base_layer.weight.data.clone()
+                    orig_weight = torch.transpose(orig_weight, 0, 1)
+                    orig_weight = torch.mm(butterfly_oft_mat, orig_weight)
+                    orig_weight = torch.transpose(orig_weight, 0, 1)
+                    orig_weight = orig_weight * boft_s
+                    self.base_layer.weight.data = orig_weight.contiguous()
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        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.boft_R.keys():
+                (butterfly_oft_mat, boft_s) = self.get_delta_weight(active_adapter)
+                orig_weight = self.get_base_layer().weight.data.clone()
+                orig_weight = torch.transpose(orig_weight, 0, 1)
+                orig_weight = torch.mm(butterfly_oft_mat.t(), orig_weight)
+                orig_weight = torch.transpose(orig_weight, 0, 1)
+                self.get_base_layer().weight.data = orig_weight * (1 / boft_s)
+
+    def get_delta_weight(self, adapter) -> tuple[torch.Tensor, torch.Tensor]:
+        boft_R = self.boft_R[adapter]
+        boft_s = self.boft_s[adapter]
+        (N, D, H, _) = boft_R.shape
+        boft_R = boft_R.view(N * D, H, H)
+        orth_rotate_butterfly = self.cayley_batch(boft_R)
+        orth_rotate_butterfly = orth_rotate_butterfly.view(N, D, H, H)
+        if self.fbd_cuda_available:
+            block_diagonal_butterfly = FastBlockDiag.apply(orth_rotate_butterfly)
+        else:
+            orth_rotate_butterfly = orth_rotate_butterfly.squeeze(0)
+            block_diagonal_butterfly = torch.block_diag(*torch.unbind(orth_rotate_butterfly))
+            block_diagonal_butterfly = block_diagonal_butterfly.unsqueeze(0)
+        boft_P = self.boft_P.to(block_diagonal_butterfly.device)
+        butterfly_oft_mat_batch = torch.bmm(block_diagonal_butterfly, boft_P.permute(0, 2, 1))
+        butterfly_oft_mat_batch = torch.bmm(boft_P, butterfly_oft_mat_batch)
+        butterfly_oft_mat = butterfly_oft_mat_batch[0]
+        for i in range(1, butterfly_oft_mat_batch.shape[0]):
+            butterfly_oft_mat = butterfly_oft_mat_batch[i] @ butterfly_oft_mat
+        return (butterfly_oft_mat, boft_s)
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        previous_dtype = x.dtype
+        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:
+            boft_rotation = torch.eye(self.in_features, device=x.device, dtype=previous_dtype)
+            boft_scale = torch.ones((int(self.out_features), 1), device=x.device, dtype=previous_dtype)
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.boft_R.keys():
+                    continue
+                boft_R = self.boft_R[active_adapter]
+                boft_s = self.boft_s[active_adapter]
+                dropout = self.boft_dropout[active_adapter]
+                (N, D, H, _) = boft_R.shape
+                boft_R = boft_R.view(N * D, H, H)
+                orth_rotate_butterfly = self.cayley_batch(boft_R)
+                orth_rotate_butterfly = orth_rotate_butterfly.view(N, D, H, H)
+                orth_rotate_butterfly = dropout(orth_rotate_butterfly)
+                if self.fbd_cuda_available:
+                    block_diagonal_butterfly = FastBlockDiag.apply(orth_rotate_butterfly)
+                else:
+                    orth_rotate_butterfly = orth_rotate_butterfly.squeeze(0)
+                    block_diagonal_butterfly = torch.block_diag(*torch.unbind(orth_rotate_butterfly))
+                    block_diagonal_butterfly = block_diagonal_butterfly.unsqueeze(0)
+                boft_P = self.boft_P.to(x)
+                block_diagonal_butterfly = block_diagonal_butterfly.to(x)
+                butterfly_oft_mat_batch = torch.bmm(block_diagonal_butterfly, boft_P.permute(0, 2, 1))
+                butterfly_oft_mat_batch = torch.bmm(boft_P, butterfly_oft_mat_batch)
+                butterfly_oft_mat = butterfly_oft_mat_batch[0]
+                for i in range(1, butterfly_oft_mat_batch.shape[0]):
+                    butterfly_oft_mat = butterfly_oft_mat_batch[i] @ butterfly_oft_mat
+                boft_rotation = butterfly_oft_mat @ boft_rotation
+                boft_scale = boft_s * boft_scale
+            x = x.to(self.get_base_layer().weight.data.dtype)
+            orig_weight = self.get_base_layer().weight.data
+            orig_weight = torch.transpose(orig_weight, 0, 1)
+            boft_rotation = boft_rotation.to(previous_dtype)
+            orig_weight = orig_weight.to(previous_dtype)
+            rotated_weight = torch.mm(boft_rotation, orig_weight)
+            rotated_weight = torch.transpose(rotated_weight, 0, 1)
+            scaled_rotated_weight = rotated_weight * boft_scale
+            scaled_rotated_weight = scaled_rotated_weight.to(previous_dtype)
+            if self.base_layer.bias is not None:
+                self.base_layer.bias = self.base_layer.bias.to(previous_dtype)
+            result = F.linear(input=x, weight=scaled_rotated_weight, bias=self.base_layer.bias)
+        result = result.to(previous_dtype)
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return 'boft.' + rep
+
+class Conv2d(nn.Module, BOFTLayer):
+
+    def __init__(self, base_layer: nn.Module, adapter_name: str, boft_block_size: int=8, boft_block_num: int=0, boft_n_butterfly_factor: int=0, boft_dropout: float=0.1, init_weights: Union[bool, str]=True, **kwargs) -> None:
+        super().__init__()
+        BOFTLayer.__init__(self, base_layer)
+        self._active_adapter = adapter_name
+        if not get_fbd_cuda():
+            self.fbd_cuda_available = False
+            boft_n_butterfly_factor = 1
+        else:
+            self.fbd_cuda_available = True
+        self.update_layer(adapter_name, boft_block_size, boft_block_num, boft_n_butterfly_factor, boft_dropout, init_weights)
+
+    def update_layer(self, adapter_name, boft_block_size, boft_block_num, boft_n_butterfly_factor, boft_dropout, init_weights):
+        boft_n_butterfly_factor = boft_n_butterfly_factor - 1
+        if boft_n_butterfly_factor < 0:
+            raise ValueError(f'You can only specify boft_n_butterfly_factor {boft_n_butterfly_factor + 1} to be a positive integer number.')
+        if boft_dropout > 0.0:
+            boft_dropout_layer = MultiplicativeDropoutLayer(p=boft_dropout)
+        else:
+            boft_dropout_layer = nn.Identity()
+        self.boft_dropout.update(nn.ModuleDict({adapter_name: boft_dropout_layer}))
+        base_layer = self.get_base_layer()
+        conv_filter_dim = self.in_features * base_layer.kernel_size[0] * base_layer.kernel_size[0]
+        if not (boft_block_size != 0) ^ (boft_block_num != 0):
+            raise ValueError(f'You can only specify either boft_block_size ({boft_block_size}) or boft_block_num ({boft_block_num}), but not both simultaneously, because boft_block_size x boft_block_num != in_features.')
+        if boft_block_size == 0 and boft_block_num != 0:
+            if conv_filter_dim % boft_block_num != 0:
+                raise ValueError(f'Convolutional kernel dimension ({conv_filter_dim}) must be divisible by boft_block_num ({boft_block_num})!')
+            if boft_n_butterfly_factor != 0:
+                if boft_n_butterfly_factor > int(math.log2(boft_block_num)):
+                    raise ValueError(f'Invalid combination of boft_n_butterfly_factor ({boft_n_butterfly_factor + 1}) and boft_block_num ({boft_block_num})!')
+                if boft_block_num % 2 ** boft_n_butterfly_factor != 0:
+                    raise ValueError(f'boft_block_num ({boft_block_num}) must be a multiple of 2 raised to the power of boft_n_butterfly_factor ({boft_n_butterfly_factor + 1})!')
+            boft_block_size = int(conv_filter_dim // boft_block_num)
+        elif boft_block_size != 0 and boft_block_num == 0:
+            if conv_filter_dim % boft_block_size != 0:
+                raise ValueError(f'Convolutional kernel dimension ({conv_filter_dim}) must be divisible by boft_block_size ({boft_block_size})!')
+            if boft_n_butterfly_factor != 0:
+                if conv_filter_dim < boft_block_size * 2 ** boft_n_butterfly_factor:
+                    raise ValueError(f'Invalid combination of convolutional kernel dimension ({conv_filter_dim}), boft_n_butterfly_factor ({boft_n_butterfly_factor + 1}) and boft_block_size ({boft_block_size})!')
+                if conv_filter_dim % (boft_block_size * 2 ** boft_n_butterfly_factor) != 0:
+                    raise ValueError(f'Invalid combination of convolutional kernel dimension ({conv_filter_dim}), boft_n_butterfly_factor ({boft_n_butterfly_factor + 1}) and boft_block_size ({boft_block_size})!')
+            boft_block_num = int(conv_filter_dim // boft_block_size)
+        else:
+            raise ValueError('Unknown error!')
+        if boft_n_butterfly_factor != 0:
+            if boft_block_num % 2 != 0:
+                raise ValueError(f'boft_block_num ({boft_block_num}) must be an even number!')
+            if boft_block_size % 2 != 0:
+                raise ValueError(f'boft_block_size ({boft_block_size}) must be an even number!')
+        P = torch.empty((boft_n_butterfly_factor + 1, conv_filter_dim, conv_filter_dim))
+        for i in range(boft_n_butterfly_factor + 1):
+            perm = self.block_butterfly_perm(conv_filter_dim, int(boft_block_num / 2 ** i), int(boft_block_size / 2), boft_n_butterfly_factor)
+            perm_mat = self.perm2mat(perm)
+            P[i] = perm_mat
+        self.register_buffer('boft_P', P, persistent=False)
+        self.boft_R[adapter_name] = nn.Parameter(torch.zeros(boft_n_butterfly_factor + 1, boft_block_num, boft_block_size, boft_block_size))
+        self.boft_s[adapter_name] = nn.Parameter(torch.ones(1, int(self.out_features)))
+        self.reset_boft_parameters(adapter_name, init_weights)
+        self.boft_block_size[adapter_name] = boft_block_size
+        self.boft_block_num[adapter_name] = boft_block_num
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters)
+
+    def merge(self, safe_merge: bool=False, adapter_names: Optional[list[str]]=None) -> None:
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            return
+        for active_adapter in adapter_names:
+            if active_adapter in self.boft_R.keys():
+                base_layer = self.get_base_layer()
+                if safe_merge:
+                    orig_weight = base_layer.weight.data.clone()
+                    (butterfly_oft_mat, boft_s) = self.get_delta_weight(active_adapter)
+                    orig_weight = orig_weight.view(self.in_features * base_layer.kernel_size[0] * base_layer.kernel_size[0], self.out_features)
+                    orig_weight = torch.mm(butterfly_oft_mat, orig_weight)
+                    orig_weight = orig_weight * boft_s
+                    orig_weight = orig_weight.view(self.out_features, self.in_features, base_layer.kernel_size[0], base_layer.kernel_size[0])
+                    self.base_layer.weight.data = orig_weight.contiguous()
+                else:
+                    (butterfly_oft_mat, boft_s) = self.get_delta_weight(active_adapter)
+                    orig_weight = base_layer.weight.data.clone()
+                    orig_weight = orig_weight.view(self.in_features * base_layer.kernel_size[0] * base_layer.kernel_size[0], self.out_features)
+                    orig_weight = torch.mm(butterfly_oft_mat, orig_weight)
+                    orig_weight = orig_weight * boft_s
+                    orig_weight = orig_weight.view(self.out_features, self.in_features, base_layer.kernel_size[0], base_layer.kernel_size[0])
+                    self.base_layer.weight.data = orig_weight.contiguous()
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        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.boft_R.keys():
+                (butterfly_oft_mat, boft_s) = self.get_delta_weight(active_adapter)
+                orig_weight = self.get_base_layer().weight.data.clone()
+                orig_weight = orig_weight.view(self.in_features * self.get_base_layer().kernel_size[0] * self.get_base_layer().kernel_size[0], self.out_features)
+                orig_weight = torch.mm(butterfly_oft_mat.t(), orig_weight)
+                orig_weight = orig_weight * (1 / boft_s)
+                orig_weight = orig_weight.view(self.out_features, self.in_features, self.get_base_layer().kernel_size[0], self.get_base_layer().kernel_size[0])
+                self.get_base_layer().weight.data = orig_weight
+
+    def get_delta_weight(self, adapter) -> tuple[torch.Tensor, torch.Tensor]:
+        boft_R = self.boft_R[adapter]
+        boft_s = self.boft_s[adapter]
+        (N, D, H, _) = boft_R.shape
+        boft_R = boft_R.view(N * D, H, H)
+        orth_rotate_butterfly = self.cayley_batch(boft_R)
+        orth_rotate_butterfly = orth_rotate_butterfly.view(N, D, H, H)
+        if self.fbd_cuda_available:
+            block_diagonal_butterfly = FastBlockDiag.apply(orth_rotate_butterfly)
+        else:
+            orth_rotate_butterfly = orth_rotate_butterfly.squeeze(0)
+            block_diagonal_butterfly = torch.block_diag(*torch.unbind(orth_rotate_butterfly))
+            block_diagonal_butterfly = block_diagonal_butterfly.unsqueeze(0)
+        boft_P = self.boft_P.to(block_diagonal_butterfly.device)
+        butterfly_oft_mat_batch = torch.bmm(block_diagonal_butterfly, boft_P.permute(0, 2, 1))
+        butterfly_oft_mat_batch = torch.bmm(boft_P, butterfly_oft_mat_batch)
+        butterfly_oft_mat = butterfly_oft_mat_batch[0]
+        for i in range(1, butterfly_oft_mat_batch.shape[0]):
+            butterfly_oft_mat = butterfly_oft_mat_batch[i] @ butterfly_oft_mat
+        return (butterfly_oft_mat, boft_s)
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        previous_dtype = x.dtype
+        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:
+            boft_rotation = torch.eye(self.in_features * self.base_layer.kernel_size[0] * self.base_layer.kernel_size[0], device=x.device, dtype=x.dtype)
+            boft_scale = torch.ones((1, int(self.out_features)), device=x.device, dtype=x.dtype)
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.boft_R.keys():
+                    continue
+                boft_R = self.boft_R[active_adapter]
+                boft_s = self.boft_s[active_adapter]
+                dropout = self.boft_dropout[active_adapter]
+                (N, D, H, _) = boft_R.shape
+                boft_R = boft_R.view(N * D, H, H)
+                orth_rotate_butterfly = self.cayley_batch(boft_R)
+                orth_rotate_butterfly = orth_rotate_butterfly.view(N, D, H, H)
+                orth_rotate_butterfly = dropout(orth_rotate_butterfly)
+                if self.fbd_cuda_available:
+                    block_diagonal_butterfly = FastBlockDiag.apply(orth_rotate_butterfly)
+                else:
+                    orth_rotate_butterfly = orth_rotate_butterfly.squeeze(0)
+                    block_diagonal_butterfly = torch.block_diag(*torch.unbind(orth_rotate_butterfly))
+                    block_diagonal_butterfly = block_diagonal_butterfly.unsqueeze(0)
+                boft_P = self.boft_P.to(x)
+                block_diagonal_butterfly = block_diagonal_butterfly.to(x)
+                butterfly_oft_mat_batch = torch.bmm(block_diagonal_butterfly, boft_P.permute(0, 2, 1))
+                butterfly_oft_mat_batch = torch.bmm(boft_P, butterfly_oft_mat_batch)
+                butterfly_oft_mat = butterfly_oft_mat_batch[0]
+                for i in range(1, butterfly_oft_mat_batch.shape[0]):
+                    butterfly_oft_mat = butterfly_oft_mat_batch[i] @ butterfly_oft_mat
+                boft_rotation = butterfly_oft_mat @ boft_rotation
+                boft_scale = boft_s * boft_scale
+            x = x.to(self.base_layer.weight.data.dtype)
+            orig_weight = self.base_layer.weight.data
+            orig_weight = orig_weight.view(self.in_features * self.base_layer.kernel_size[0] * self.base_layer.kernel_size[0], self.out_features)
+            rotated_weight = torch.mm(boft_rotation, orig_weight)
+            scaled_rotated_weight = rotated_weight * boft_scale
+            scaled_rotated_weight = scaled_rotated_weight.view(self.out_features, self.in_features, self.base_layer.kernel_size[0], self.base_layer.kernel_size[0])
+            result = F.conv2d(input=x, weight=scaled_rotated_weight, bias=self.base_layer.bias, padding=self.base_layer.padding[0], stride=self.base_layer.stride[0])
+        result = result.to(previous_dtype)
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return 'boft.' + rep
+
+# File: peft-main/src/peft/tuners/boft/model.py
+import warnings
+from dataclasses import asdict
+from enum import Enum
+from typing import List, Optional
+import torch
+from torch import nn
+from tqdm import tqdm
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer, check_target_module_exists, onload_layer
+from peft.utils import TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING, ModulesToSaveWrapper, _get_submodules
+from .config import BOFTConfig
+from .layer import BOFTLayer, Conv2d, Linear
+
+class BOFTModel(BaseTuner):
+    prefix: str = 'boft_'
+
+    def __init__(self, model, config, adapter_name) -> None:
+        super().__init__(model, config, adapter_name)
+
+    def _check_new_adapter_config(self, config: BOFTConfig) -> None:
+        if len(self.peft_config) > 1 and config.bias != 'none':
+            raise ValueError(f"{self.__class__.__name__} supports only 1 adapter with bias. When using multiple adapters, set bias to 'none' for all adapters.")
+
+    @staticmethod
+    def _check_target_module_exists(boft_config, key):
+        return check_target_module_exists(boft_config, key)
+
+    def _create_and_replace(self, boft_config, adapter_name, target, target_name, parent, current_key, **optional_kwargs):
+        if current_key is None:
+            raise ValueError("Current Key shouldn't be `None`")
+        bias = hasattr(target, 'bias') and target.bias is not None
+        kwargs = {'boft_block_size': boft_config.boft_block_size, 'boft_block_num': boft_config.boft_block_num, 'boft_n_butterfly_factor': boft_config.boft_n_butterfly_factor, 'boft_dropout': boft_config.boft_dropout, 'fan_in_fan_out': boft_config.fan_in_fan_out, 'init_weights': boft_config.init_weights}
+        kwargs['bias'] = bias
+        if not isinstance(target, BOFTLayer):
+            new_module = self._create_new_module(boft_config, adapter_name, target, **kwargs)
+            if adapter_name not in self.active_adapters:
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+        else:
+            target.update_layer(adapter_name, boft_block_size=boft_config.boft_block_size, boft_block_num=boft_config.boft_block_num, boft_n_butterfly_factor=boft_config.boft_n_butterfly_factor, boft_dropout=boft_config.boft_dropout, init_weights=boft_config.init_weights)
+
+    def _replace_module(self, parent, child_name, new_module, child):
+        setattr(parent, child_name, new_module)
+        if hasattr(child, 'base_layer'):
+            child = child.base_layer
+        if not hasattr(new_module, 'base_layer'):
+            new_module.weight = child.weight
+            if hasattr(child, 'bias'):
+                new_module.bias = child.bias
+        if getattr(child, 'state', None) is not None:
+            if hasattr(new_module, 'base_layer'):
+                new_module.base_layer.state = child.state
+            else:
+                new_module.state = child.state
+            new_module.to(child.weight.device)
+        for (name, module) in new_module.named_modules():
+            if self.prefix in name:
+                module.to(child.weight.device)
+
+    def _mark_only_adapters_as_trainable(self, model: nn.Module) -> None:
+        for (n, p) in model.named_parameters():
+            if self.prefix not in n:
+                p.requires_grad = False
+        for active_adapter in self.active_adapters:
+            bias = self.peft_config[active_adapter].bias
+            if bias == 'none':
+                continue
+            if bias == 'all':
+                for (n, p) in model.named_parameters():
+                    if 'bias' in n:
+                        p.requires_grad = True
+            elif bias == 'boft_only':
+                for (name, m) in model.named_modules():
+                    if isinstance(m, BOFTLayer) and hasattr(m, 'bias') and (m.bias is not None):
+                        m.bias.requires_grad = True
+            else:
+                raise NotImplementedError(f'Requested bias: {bias}, is not implemented.')
+
+    @staticmethod
+    def _create_new_module(boft_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):
+            if kwargs['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.')
+                kwargs['fan_in_fan_out'] = boft_config.fan_in_fan_out = False
+            new_module = Linear(target, adapter_name, **kwargs)
+        elif isinstance(target_base_layer, torch.nn.Conv2d):
+            new_module = Conv2d(target, adapter_name, **kwargs)
+        else:
+            raise ValueError(f'Target module {target} is not supported. Currently, only `torch.nn.Linear` and `torch.nn.Conv2d` are supported.')
+        return new_module
+
+    def __getattr__(self, name: str):
+        try:
+            return super().__getattr__(name)
+        except AttributeError:
+            if name == 'model':
+                raise
+            return getattr(self.model, name)
+
+    def get_peft_config_as_dict(self, inference: bool=False):
+        config_dict = {}
+        for (key, value) in self.peft_config.items():
+            config = {k: v.value if isinstance(v, Enum) else v for (k, v) in asdict(value).items()}
+            if inference:
+                config['inference_mode'] = True
+        config_dict[key] = config
+        return config
+
+    def _set_adapter_layers(self, enabled=True):
+        for module in self.model.modules():
+            if isinstance(module, (BaseTunerLayer, ModulesToSaveWrapper)):
+                module.enable_adapters(enabled)
+
+    def enable_adapter_layers(self):
+        self._set_adapter_layers(enabled=True)
+
+    def disable_adapter_layers(self):
+        for active_adapter in self.active_adapters:
+            val = self.peft_config[active_adapter].bias
+            if val != 'none':
+                msg = f"Careful, disabling adapter layers with bias configured to be '{val}' does not produce the same output as the the base model would without adaption."
+                warnings.warn(msg)
+        self._set_adapter_layers(enabled=False)
+
+    def set_adapter(self, adapter_name):
+        for module in self.model.modules():
+            if isinstance(module, BOFTLayer):
+                if module.merged:
+                    warnings.warn('Adapter cannot be set when the model is merged. Unmerging the model first.')
+                    module.unmerge()
+                module.set_adapter(adapter_name)
+        self.active_adapter = adapter_name
+
+    @staticmethod
+    def _prepare_adapter_config(peft_config, model_config):
+        if peft_config.target_modules is None:
+            if model_config['model_type'] not in TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING:
+                raise ValueError('Please specify `target_modules` in `peft_config`')
+            peft_config.target_modules = set(TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING[model_config['model_type']])
+        return peft_config
+
+    def _unload_and_optionally_merge(self, merge=True, progressbar: bool=False, safe_merge: bool=False, adapter_names: Optional[List[str]]=None):
+        if merge:
+            self._check_merge_allowed()
+        key_list = [key for (key, _) in self.model.named_modules() if self.prefix not in key]
+        desc = 'Unloading ' + ('and merging ' if merge else '') + 'model'
+        for key in tqdm(key_list, disable=not progressbar, desc=desc):
+            try:
+                (parent, target, target_name) = _get_submodules(self.model, key)
+            except AttributeError:
+                continue
+            with onload_layer(target):
+                if hasattr(target, 'base_layer'):
+                    if merge:
+                        target.merge(safe_merge=safe_merge, adapter_names=adapter_names)
+                    self._replace_module(parent, target_name, target.get_base_layer(), target)
+                elif isinstance(target, ModulesToSaveWrapper):
+                    new_module = target.modules_to_save[target.active_adapter]
+                    if hasattr(new_module, 'base_layer'):
+                        if merge:
+                            new_module.merge(safe_merge=safe_merge, adapter_names=adapter_names)
+                        new_module = new_module.get_base_layer()
+                    setattr(parent, target_name, new_module)
+        return self.model
+
+    def delete_adapter(self, adapter_name: str) -> None:
+        if adapter_name not in list(self.peft_config.keys()):
+            raise ValueError(f'Adapter {adapter_name} does not exist')
+        del self.peft_config[adapter_name]
+        key_list = [key for (key, _) in self.model.named_modules() if self.prefix not in key]
+        new_adapter = None
+        for key in key_list:
+            (_, target, _) = _get_submodules(self.model, key)
+            if isinstance(target, BOFTLayer):
+                target.delete_adapter(adapter_name)
+                if new_adapter is None:
+                    new_adapter = target.active_adapters[:]
+        self.active_adapter = new_adapter or []
+
+    def merge_and_unload(self, progressbar: bool=False, safe_merge: bool=False, adapter_names: Optional[List[str]]=None) -> torch.nn.Module:
+        return self._unload_and_optionally_merge(progressbar=progressbar, safe_merge=safe_merge, adapter_names=adapter_names)
+
+    def unload(self) -> torch.nn.Module:
+        return self._unload_and_optionally_merge(merge=False)
+
+# File: peft-main/src/peft/tuners/fourierft/config.py
+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 FourierFTConfig(PeftConfig):
+    n_frequency: int = field(default=1000, metadata={'help': "Num of learnable frequencies for the Discrete Fourier Transform. 'n_frequency' is an integer that isgreater than 0 and less than or equal to d^2 (assuming the weight W has dimensions of d by d).Additionally, it is the number of trainable parameters required to update each delta W weight.'n_frequency' will affect the performance and efficiency for PEFT. Specifically, it has little impact ontraining speed, but higher values of it (typically) result in larger GPU memory costs and better accuracy.With the same `target_modules`, the number of parameters of LoRA is (2*d*r/n_frequency) times that of FourierFT.The following examples of settings regarding 'n_frequency' can be used as reference for users. For NLUtasks with the RoBERTa-large model, adopting 'n_frequency': 1000 can almost achieve similar results as'r': 8 in LoRA. At this time, the number of parameters of LoRA is about 16 times that of FourierFT.For image classification tasks with Vit-large models, adopting 'n_frequency': 3000 can almost achievesimilar results as 'r': 16 in LoRA, where the number of parameters of LoRA is about 11 times that of FourierFT."})
+    scaling: float = field(default=150.0, metadata={'help': "The scaling value for the delta W matrix. This is an important hyperparameter used for scaling, similar to the'lora_alpha' parameter in the LoRA method. 'scaling' can be determined during the hyperparameter search process.However, if users want to skip this process, one can refer to the settings in the following scenarios.This parameter can be set to 100.0 or 150.0 for both RoBERTa-base and RoBERTa-large models across all NLU (GLUE) tasks.This parameter can be set to 300.0 for both LLaMA family models for all instruction tuning.This parameter can be set to 300.0 for both ViT-base and ViT-large models across all image classification tasks."})
+    random_loc_seed: Optional[int] = field(default=777, metadata={'help': 'Seed for the random location of the frequencies.'})
+    fan_in_fan_out: bool = field(default=False, metadata={'help': 'Set this to True if the layer to replace stores weight like (fan_in, fan_out)'})
+    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 FourierFT.For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'. Only linear layers are supported."})
+    bias: str = field(default='none', metadata={'help': "Bias type for FourierFT. Can be 'none', 'all' or 'fourier_only'."})
+    modules_to_save: Optional[list[str]] = field(default=None, metadata={'help': 'List of modules apart from FourierFT 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': 'The layer indexes to transform, is this argument is specified, PEFT will transform only the layers indexes that are specified inside this list. If a single integer is passed, PEFT will transform only the layer at this index.'})
+    layers_pattern: Optional[str] = field(default=None, metadata={'help': 'The layer pattern name, used only if `layers_to_transform` is different to None and if the layer pattern is not in the common layers pattern.'})
+    n_frequency_pattern: Optional[dict] = field(default_factory=dict, metadata={'help': 'The mapping from layer names or regexp expression to n_frequency which are different from the default specified.For example, `{model.decoder.layers.0.encoder_attn.k_proj: 500`}.'})
+    init_weights: bool = field(default=False, metadata={'help': 'The initialization of the Fourier weights. Set this to False if the spectrum should be initialized to a standard normal distribution.Set this to True if the spectrum should be initialized to zeros.'})
+
+    def __post_init__(self):
+        self.peft_type = PeftType.FOURIERFT
+        self.target_modules = set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        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.')
+        if isinstance(self.target_modules, str) and self.layers_pattern is not None:
+            raise ValueError('`layers_pattern` cannot be used when `target_modules` is a str.')
+
+# File: peft-main/src/peft/tuners/fourierft/layer.py
+import warnings
+from typing import Any, List, Optional, Union
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from transformers.pytorch_utils import Conv1D
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+
+class FourierFTLayer(BaseTunerLayer):
+    adapter_layer_names = ('fourierft_spectrum',)
+    other_param_names = ('fourierft_n_frequency', 'fourierft_scaling', 'fourierft_random_loc_seed')
+
+    def __init__(self, base_layer: nn.Module, **kwargs) -> None:
+        self.base_layer = base_layer
+        self.fourierft_n_frequency = {}
+        self.fourierft_scaling = {}
+        self.fourierft_spectrum = nn.ParameterDict({})
+        self.indices = {}
+        self.fourierft_random_loc_seed = {}
+        self._disable_adapters = False
+        self.merged_adapters = []
+        self.kwargs = kwargs
+        base_layer = self.get_base_layer()
+        if isinstance(base_layer, nn.Linear):
+            (self.in_features, self.out_features) = (base_layer.in_features, base_layer.out_features)
+        elif isinstance(base_layer, Conv1D):
+            (self.in_features, self.out_features) = base_layer.weight.ds_shape if hasattr(base_layer.weight, 'ds_shape') else base_layer.weight.shape
+        else:
+            raise ValueError(f'Unsupported layer type {type(base_layer)}')
+
+    def update_layer(self, adapter_name, n_frequency, scaling, init_weights, random_loc_seed):
+        if n_frequency <= 0:
+            raise ValueError(f'`n_frequency` should be a positive integer value but the value passed is {n_frequency}')
+        if n_frequency > self.in_features * self.out_features:
+            raise ValueError(f'`n_frequency` should be less than or equal to the product of the input and output dimensions but the value passed is {n_frequency} and the product is {self.in_features * self.out_features}')
+        self.fourierft_n_frequency[adapter_name] = n_frequency
+        self.fourierft_random_loc_seed[adapter_name] = random_loc_seed
+        self.indices[adapter_name] = torch.randperm(self.out_features * self.in_features, generator=torch.Generator().manual_seed(self.fourierft_random_loc_seed[adapter_name]))[:n_frequency]
+        self.indices[adapter_name] = torch.stack([self.indices[adapter_name] // self.in_features, self.indices[adapter_name] % self.in_features], dim=0)
+        self.fourierft_scaling[adapter_name] = scaling
+        self.fourierft_spectrum[adapter_name] = nn.Parameter(torch.randn(n_frequency), requires_grad=True)
+        if init_weights:
+            self.reset_fourier_parameters(adapter_name)
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters)
+
+    @torch.no_grad()
+    def reset_fourier_parameters(self, adapter_name):
+        if adapter_name in self.fourierft_spectrum.keys():
+            nn.init.zeros_(self.fourierft_spectrum[adapter_name])
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        spectrum = self.fourierft_spectrum[adapter]
+        indices = self.indices[adapter].to(spectrum.device)
+        dense_spectrum = torch.zeros(self.out_features, self.in_features, device=spectrum.device, dtype=spectrum.dtype)
+        dense_spectrum[indices[0, :], indices[1, :]] = spectrum
+        delta_weight = torch.fft.ifft2(dense_spectrum).real * self.fourierft_scaling[adapter]
+        return delta_weight
+
+class FourierFTLinear(nn.Module, FourierFTLayer):
+
+    def __init__(self, base_layer, adapter_name: str, n_frequency: int=1000, scaling: float=150.0, fan_in_fan_out: bool=False, init_weights: Union[bool, str]=False, random_loc_seed: int=777, **kwargs) -> None:
+        super().__init__()
+        FourierFTLayer.__init__(self, base_layer, **kwargs)
+        self.fan_in_fan_out = fan_in_fan_out
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, n_frequency, scaling, init_weights, random_loc_seed)
+
+    def merge(self, safe_merge: bool=False, adapter_names: Optional[List[str]]=None) -> None:
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            return
+        for active_adapter in adapter_names:
+            if active_adapter in self.fourierft_spectrum.keys():
+                base_layer = self.get_base_layer()
+                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:
+        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.fourierft_spectrum.keys():
+                self.get_base_layer().weight.data -= self.get_delta_weight(active_adapter)
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        return super().get_delta_weight(adapter)
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        previous_dtype = x.dtype
+        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.fourierft_spectrum.keys():
+                    continue
+                delta_w = self.get_delta_weight(active_adapter)
+                x = x.to(delta_w.dtype)
+                result = result + F.linear(x, delta_w)
+        result = result.to(previous_dtype)
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return 'fourierft.' + rep
+
+# File: peft-main/src/peft/tuners/fourierft/model.py
+from __future__ import annotations
+import re
+import warnings
+from dataclasses import asdict
+from enum import Enum
+from itertools import chain
+from typing import Optional
+import torch
+from tqdm import tqdm
+from transformers.pytorch_utils import Conv1D
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer, check_target_module_exists
+from peft.utils import TRANSFORMERS_MODELS_TO_FOURIERFT_TARGET_MODULES_MAPPING, ModulesToSaveWrapper, _get_submodules
+from .config import FourierFTConfig
+from .layer import FourierFTLayer, FourierFTLinear
+
+class FourierFTModel(BaseTuner):
+    prefix: str = 'fourierft_'
+
+    def __init__(self, model, config, adapter_name) -> None:
+        super().__init__(model, config, adapter_name)
+
+    def _check_new_adapter_config(self, config: FourierFTConfig) -> None:
+        if len(self.peft_config) > 1 and config.bias != 'none':
+            raise ValueError(f"{self.__class__.__name__} supports only 1 adapter with bias. When using multiple adapters, set bias to 'none' for all adapters.")
+
+    @staticmethod
+    def _check_target_module_exists(fourierft_config, key):
+        return check_target_module_exists(fourierft_config, key)
+
+    def _create_and_replace(self, fourierft_config, adapter_name, target, target_name, parent, current_key, **optional_kwargs):
+        if current_key is None:
+            raise ValueError("Current Key shouldn't be `None`")
+        pattern_keys = list(chain(fourierft_config.n_frequency_pattern.keys()))
+        target_name_key = next(filter(lambda key: re.match(f'.*\\.{key}$', current_key), pattern_keys), current_key)
+        n_frequency = fourierft_config.n_frequency_pattern.get(target_name_key, fourierft_config.n_frequency)
+        scaling = fourierft_config.scaling
+        random_loc_seed = fourierft_config.random_loc_seed
+        bias = hasattr(target, 'bias') and target.bias is not None
+        kwargs = {'n_frequency': n_frequency, 'scaling': scaling, 'fan_in_fan_out': fourierft_config.fan_in_fan_out, 'init_weights': fourierft_config.init_weights, 'random_loc_seed': fourierft_config.random_loc_seed}
+        kwargs['bias'] = bias
+        if isinstance(target, FourierFTLayer):
+            target.update_layer(adapter_name, n_frequency, scaling, fourierft_config.init_weights, random_loc_seed)
+        else:
+            new_module = self._create_new_module(fourierft_config, adapter_name, target, **kwargs)
+            if adapter_name != self.active_adapter:
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+
+    def _replace_module(self, parent, child_name, new_module, child):
+        setattr(parent, child_name, new_module)
+        if hasattr(child, 'base_layer'):
+            child = child.base_layer
+        if not hasattr(new_module, 'base_layer'):
+            new_module.weight = child.weight
+            if hasattr(child, 'bias'):
+                new_module.bias = child.bias
+        if getattr(child, 'state', None) is not None:
+            if hasattr(new_module, 'base_layer'):
+                new_module.base_layer.state = child.state
+            else:
+                new_module.state = child.state
+            new_module.to(child.weight.device)
+        for (name, module) in new_module.named_modules():
+            if 'fourierft_' in name:
+                module.to(child.weight.device)
+
+    def _mark_only_adapters_as_trainable(self, model: torch.nn.Module) -> None:
+        for (n, p) in model.named_parameters():
+            if self.prefix not in n:
+                p.requires_grad = False
+        for active_adapter in self.active_adapters:
+            bias = self.peft_config[active_adapter].bias
+            if bias == 'none':
+                continue
+            if bias == 'all':
+                for (n, p) in model.named_parameters():
+                    if 'bias' in n:
+                        p.requires_grad = True
+            elif bias == 'fourier_only':
+                for m in model.modules():
+                    if isinstance(m, FourierFTLayer) and hasattr(m, 'bias') and (m.bias is not None):
+                        m.bias.requires_grad = True
+            else:
+                raise NotImplementedError(f'Requested bias: {bias}, is not implemented.')
+
+    @staticmethod
+    def _create_new_module(fourierft_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):
+            if kwargs['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.')
+                kwargs['fan_in_fan_out'] = fourierft_config.fan_in_fan_out = False
+        elif isinstance(target_base_layer, Conv1D):
+            kwargs['is_target_conv_1d_layer'] = True
+            if not kwargs['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.')
+                kwargs['fan_in_fan_out'] = fourierft_config.fan_in_fan_out = True
+        else:
+            raise ValueError(f'Target module {target} is not supported. Currently, only the following modules are supported: `torch.nn.Linear`.')
+        new_module = FourierFTLinear(target, adapter_name, **kwargs)
+        return new_module
+
+    def __getattr__(self, name: str):
+        try:
+            return super().__getattr__(name)
+        except AttributeError:
+            if name == 'model':
+                raise
+            return getattr(self.model, name)
+
+    def get_peft_config_as_dict(self, inference: bool=False):
+        config_dict = {}
+        for (key, value) in self.peft_config.items():
+            config = {k: v.value if isinstance(v, Enum) else v for (k, v) in asdict(value).items()}
+            if inference:
+                config['inference_mode'] = True
+        config_dict[key] = config
+        return config
+
+    def _set_adapter_layers(self, enabled: bool=True) -> None:
+        for module in self.model.modules():
+            if isinstance(module, (BaseTunerLayer, ModulesToSaveWrapper)):
+                module.enable_adapters(enabled)
+
+    def enable_adapter_layers(self) -> None:
+        self._set_adapter_layers(enabled=True)
+
+    def disable_adapter_layers(self) -> None:
+        for active_adapter in self.active_adapters:
+            val = self.peft_config[active_adapter].bias
+            if val != 'none':
+                msg = f"Careful, disabling adapter layers with bias configured to be '{val}' does not produce the same output as the the base model would without adaption."
+                warnings.warn(msg)
+        self._set_adapter_layers(enabled=False)
+
+    def set_adapter(self, adapter_name: str | list[str]) -> None:
+        for module in self.model.modules():
+            if isinstance(module, FourierFTLayer):
+                if module.merged:
+                    warnings.warn('Adapter cannot be set when the model is merged. Unmerging the model first.')
+                    module.unmerge()
+                module.set_adapter(adapter_name)
+        self.active_adapter = adapter_name
+
+    @staticmethod
+    def _prepare_adapter_config(peft_config, model_config):
+        if peft_config.target_modules is None:
+            if model_config['model_type'] not in TRANSFORMERS_MODELS_TO_FOURIERFT_TARGET_MODULES_MAPPING:
+                raise ValueError('Please specify `target_modules` in `peft_config`')
+            peft_config.target_modules = set(TRANSFORMERS_MODELS_TO_FOURIERFT_TARGET_MODULES_MAPPING[model_config['model_type']])
+        return peft_config
+
+    def _unload_and_optionally_merge(self, merge=True, progressbar: bool=False, safe_merge: bool=False, adapter_names: Optional[list[str]]=None):
+        key_list = [key for (key, _) in self.model.named_modules() if self.prefix not in key]
+        desc = 'Unloading ' + ('and merging ' if merge else '') + 'model'
+        for key in tqdm(key_list, disable=not progressbar, desc=desc):
+            try:
+                (parent, target, target_name) = _get_submodules(self.model, key)
+            except AttributeError:
+                continue
+            if hasattr(target, 'base_layer'):
+                if merge:
+                    target.merge(safe_merge=safe_merge, adapter_names=adapter_names)
+                self._replace_module(parent, target_name, target.get_base_layer(), target)
+            elif isinstance(target, ModulesToSaveWrapper):
+                setattr(parent, target_name, target.modules_to_save[target.active_adapter])
+        return self.model
+
+    def delete_adapter(self, adapter_name: str):
+        if adapter_name not in list(self.peft_config.keys()):
+            raise ValueError(f'Adapter {adapter_name} does not exist')
+        del self.peft_config[adapter_name]
+        key_list = [key for (key, _) in self.model.named_modules() if 'fourierft' not in key]
+        new_adapter = None
+        for key in key_list:
+            (_, target, _) = _get_submodules(self.model, key)
+            if isinstance(target, FourierFTLayer):
+                target.delete_adapter(adapter_name)
+                if new_adapter is None:
+                    new_adapter = target.active_adapter[:]
+        self.active_adapter = new_adapter or []
+
+    def merge_and_unload(self, progressbar: bool=False, safe_merge: bool=False, adapter_names: Optional[list[str]]=None) -> torch.nn.Module:
+        return self._unload_and_optionally_merge(progressbar=progressbar, safe_merge=safe_merge, adapter_names=adapter_names)
+
+    def unload(self) -> torch.nn.Module:
+        return self._unload_and_optionally_merge(merge=False)
+
+# File: peft-main/src/peft/tuners/hra/config.py
+from dataclasses import dataclass, field
+from typing import List, Optional, Union
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+@dataclass
+class HRAConfig(PeftConfig):
+    r: int = field(default=8, metadata={'help': 'The rank of HRA across different layers.', 'note': "It is best to set 'r' to an even number; otherwise, the default initialization method will not work."})
+    apply_GS: bool = field(default=False, metadata={'help': 'Whether to apply Gram-Schmidt orthogonalization or not.'})
+    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 HRA.', 'example': "For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$' "})
+    init_weights: bool = field(default=True, metadata={'help': "Whether to initialize the weights of the HRA layers with their default initialization. Don't change this setting, except if you know exactly what you're doing."})
+    layers_to_transform: Optional[Union[List[int], int]] = field(default=None, metadata={'help': 'The layer indexes to transform, is this argument is specified, PEFT will transform only the layers indexes that are specified inside this list. If a single integer is passed, PEFT will transform only the layer at this index.'})
+    layers_pattern: Optional[str] = field(default=None, metadata={'help': 'The layer pattern name, used only if `layers_to_transform` is different to None and if the layer pattern is not in the common layers pattern.'})
+    bias: str = field(default='none', metadata={'help': "Bias type for HRA. Can be 'none', 'all' or 'hra_only'"})
+    modules_to_save: Optional[List[str]] = field(default=None, metadata={'help': 'List of modules apart from HRA 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.'})
+
+    def __post_init__(self):
+        self.peft_type = PeftType.HRA
+        self.target_modules = set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        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.')
+        if isinstance(self.target_modules, str) and self.layers_pattern is not None:
+            raise ValueError('`layers_pattern` cannot be used when `target_modules` is a str.')
+
+# File: peft-main/src/peft/tuners/hra/layer.py
+import math
+import warnings
+from typing import Any, List, Optional, Union
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+
+class HRALayer(BaseTunerLayer):
+    adapter_layer_names = ('hra_u',)
+    other_param_names = ('hra_r', 'hra_apply_GS')
+
+    def __init__(self, base_layer: nn.Module, **kwargs) -> None:
+        self.base_layer = base_layer
+        self.hra_r = {}
+        self.hra_apply_GS = {}
+        self.hra_u = nn.ParameterDict({})
+        self._disable_adapters = False
+        self.merged_adapters = []
+        self.kwargs = kwargs
+        base_layer = self.get_base_layer()
+        if isinstance(base_layer, nn.Linear):
+            (self.in_features, self.out_features) = (base_layer.in_features, base_layer.out_features)
+        elif isinstance(base_layer, nn.Conv2d):
+            (self.in_features, self.out_features) = (base_layer.in_channels, base_layer.out_channels)
+        else:
+            raise ValueError(f'Unsupported layer type {type(base_layer)}')
+
+    def update_layer(self, adapter_name: str, r: int, apply_GS: bool, init_weights: bool, **kwargs) -> None:
+        if r <= 0:
+            raise ValueError(f'`r` should be a positive integer value but the value passed is {r}')
+        self.hra_r[adapter_name] = r
+        self.hra_apply_GS[adapter_name] = apply_GS
+        base_layer = self.get_base_layer()
+        if isinstance(base_layer, nn.Linear):
+            self.hra_u[adapter_name] = nn.Parameter(torch.empty(self.in_features, r), requires_grad=True)
+        elif isinstance(base_layer, nn.Conv2d):
+            self.hra_u[adapter_name] = nn.Parameter(torch.empty(self.in_features * base_layer.kernel_size[0] * base_layer.kernel_size[0], r), requires_grad=True)
+        else:
+            raise TypeError(f'HRA is not implemented for base layers of type {type(base_layer).__name__}')
+        if init_weights:
+            self.reset_hra_parameters(adapter_name)
+        else:
+            self.reset_hra_parameters_random(adapter_name)
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters)
+
+    def reset_hra_parameters(self, adapter_name: str):
+        if self.hra_r[adapter_name] % 2 != 0:
+            warnings.warn('The symmetric initialization can NOT be performed when r is odd!')
+            nn.init.kaiming_uniform_(self.hra_u[adapter_name], a=math.sqrt(5))
+        else:
+            shape = self.hra_u[adapter_name].shape
+            half_u = torch.zeros(shape[0], shape[1] // 2)
+            nn.init.kaiming_uniform_(half_u, a=math.sqrt(5))
+            self.hra_u[adapter_name] = nn.Parameter(torch.repeat_interleave(half_u, 2, dim=1))
+
+    def reset_hra_parameters_random(self, adapter_name: str):
+        nn.init.kaiming_uniform_(self.hra_u[adapter_name], a=math.sqrt(5))
+
+    def scale_layer(self, scale: float) -> None:
+        if scale == 1:
+            return
+        for active_adapter in self.active_adapters:
+            if active_adapter not in self.hra_u.keys():
+                continue
+            warnings.warn('Scaling operation for HRA not supported! Automatically set scale to 1.')
+
+    def unscale_layer(self, scale=None) -> None:
+        for active_adapter in self.active_adapters:
+            if active_adapter not in self.hra_u.keys():
+                continue
+            warnings.warn('Unscaling operation for HRA not supported! Keeping scale at 1.')
+
+class HRALinear(nn.Module, HRALayer):
+
+    def __init__(self, base_layer, adapter_name: str, r: int=0, apply_GS: bool=False, init_weights: Union[bool, str]=True, **kwargs) -> None:
+        super().__init__()
+        HRALayer.__init__(self, base_layer, **kwargs)
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, apply_GS, init_weights, **kwargs)
+
+    def merge(self, safe_merge: bool=False, adapter_names: Optional[List[str]]=None) -> None:
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            return
+        for active_adapter in adapter_names:
+            if active_adapter in self.hra_u.keys():
+                base_layer = self.get_base_layer()
+                if safe_merge:
+                    orig_weight = base_layer.weight.data.clone()
+                    delta_weight = self.get_delta_weight(active_adapter)
+                    orig_weight = torch.mm(orig_weight, delta_weight)
+                    if not torch.isfinite(orig_weight).all():
+                        raise ValueError(f'NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken')
+                    self.base_layer.weight.data = orig_weight
+                else:
+                    delta_weight = self.get_delta_weight(active_adapter)
+                    self.base_layer.weight.data = torch.mm(self.base_layer.weight.data, delta_weight)
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        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.hra_u.keys():
+                orig_weight = self.get_base_layer().weight.data.clone()
+                delta_weight = self.get_delta_weight(active_adapter, reverse=True)
+                self.get_base_layer().weight.data = torch.mm(orig_weight, delta_weight)
+
+    def get_delta_weight(self, adapter_name: str, reverse: bool=False) -> torch.Tensor:
+        rank = self.hra_r[adapter_name]
+        apply_GS = self.hra_apply_GS[adapter_name]
+        opt_u = self.hra_u[adapter_name]
+        shape = opt_u.shape
+        if apply_GS:
+            weight = [(opt_u[:, 0] / opt_u[:, 0].norm()).view(-1, 1)]
+            for i in range(1, rank):
+                ui = opt_u[:, i].view(-1, 1)
+                for j in range(i):
+                    ui = ui - weight[j].t() @ ui * weight[j]
+                weight.append((ui / ui.norm()).view(-1, 1))
+            weight = torch.cat(weight, dim=1)
+            weight = torch.eye(shape[0], device=opt_u.device, dtype=opt_u.dtype) - 2 * weight @ weight.t()
+        else:
+            opt_u = opt_u / opt_u.norm(dim=0)
+            weight = torch.eye(shape[0], device=opt_u.device, dtype=opt_u.dtype)
+            if reverse:
+                indices = range(rank - 1, -1, -1)
+            else:
+                indices = range(rank)
+            for i in indices:
+                ui = opt_u[:, i].view(-1, 1)
+                weight = weight @ (torch.eye(shape[0], device=opt_u.device, dtype=opt_u.dtype) - 2 * ui @ ui.t())
+        return weight
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        previous_dtype = x.dtype
+        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:
+            new_weight = torch.eye(self.in_features, device=x.device)
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.hra_u.keys():
+                    continue
+                delta_weight = self.get_delta_weight(active_adapter)
+                new_weight = torch.mm(new_weight, delta_weight)
+            x = x.to(self.get_base_layer().weight.data.dtype)
+            orig_weight = self.get_base_layer().weight.data
+            new_weight = torch.mm(orig_weight, new_weight)
+            result = F.linear(input=x, weight=new_weight, bias=self.base_layer.bias)
+        result = result.to(previous_dtype)
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return 'hra.' + rep
+
+class HRAConv2d(nn.Module, HRALayer):
+
+    def __init__(self, base_layer, adapter_name: str, r: int=0, apply_GS: bool=False, init_weights: Union[bool, str]=True, **kwargs):
+        super().__init__()
+        HRALayer.__init__(self, base_layer)
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, apply_GS, init_weights, **kwargs)
+
+    def merge(self, safe_merge: bool=False, adapter_names: Optional[List[str]]=None) -> None:
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            return
+        for active_adapter in adapter_names:
+            if active_adapter in self.hra_u.keys():
+                base_layer = self.get_base_layer()
+                if safe_merge:
+                    orig_weight = base_layer.weight.data.clone()
+                    orig_weight = orig_weight.view(self.out_features, self.in_features * self.base_layer.kernel_size[0] * self.base_layer.kernel_size[0])
+                    delta_weight = self.get_delta_weight(active_adapter)
+                    orig_weight = torch.mm(orig_weight, delta_weight)
+                    orig_weight = orig_weight.view(self.out_features, self.in_features, self.base_layer.kernel_size[0], self.base_layer.kernel_size[0])
+                    if not torch.isfinite(orig_weight).all():
+                        raise ValueError(f'NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken')
+                    self.base_layer.weight.data = orig_weight
+                else:
+                    orig_weight = base_layer.weight.data
+                    orig_weight = orig_weight.view(self.out_features, self.in_features * self.base_layer.kernel_size[0] * self.base_layer.kernel_size[0])
+                    delta_weight = self.get_delta_weight(active_adapter)
+                    orig_weight = torch.mm(orig_weight, delta_weight)
+                    orig_weight = orig_weight.view(self.out_features, self.in_features, self.base_layer.kernel_size[0], self.base_layer.kernel_size[0])
+                    self.base_layer.weight.data = orig_weight
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        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.hra_u.keys():
+                orig_weight = self.get_base_layer().weight.data.clone()
+                orig_weight = orig_weight.view(self.out_features, self.in_features * self.base_layer.kernel_size[0] * self.base_layer.kernel_size[0])
+                delta_weight = self.get_delta_weight(active_adapter, reverse=True)
+                orig_weight = torch.mm(orig_weight, delta_weight)
+                orig_weight = orig_weight.view(self.out_features, self.in_features, self.base_layer.kernel_size[0], self.base_layer.kernel_size[0])
+                self.get_base_layer().weight.data = orig_weight
+
+    def get_delta_weight(self, adapter_name: str, reverse: bool=False) -> torch.Tensor:
+        rank = self.hra_r[adapter_name]
+        apply_GS = self.hra_apply_GS[adapter_name]
+        opt_u = self.hra_u[adapter_name]
+        shape = opt_u.shape
+        if apply_GS:
+            weight = [(opt_u[:, 0] / opt_u[:, 0].norm()).view(-1, 1)]
+            for i in range(1, rank):
+                ui = opt_u[:, i].view(-1, 1)
+                for j in range(i):
+                    ui = ui - weight[j].t() @ ui * weight[j]
+                weight.append((ui / ui.norm()).view(-1, 1))
+            weight = torch.cat(weight, dim=1)
+            weight = torch.eye(shape[0], device=opt_u.device, dtype=opt_u.dtype) - 2 * weight @ weight.t()
+        else:
+            opt_u = opt_u / opt_u.norm(dim=0)
+            weight = torch.eye(shape[0], device=opt_u.device, dtype=opt_u.dtype)
+            if reverse:
+                indices = range(rank - 1, -1, -1)
+            else:
+                indices = range(rank)
+            for i in indices:
+                ui = opt_u[:, i].view(-1, 1)
+                weight = weight @ (torch.eye(shape[0], device=opt_u.device, dtype=opt_u.dtype) - 2 * ui @ ui.t())
+        return weight
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        previous_dtype = x.dtype
+        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:
+            new_weight = torch.eye(self.in_features * self.base_layer.kernel_size[0] * self.base_layer.kernel_size[0], device=x.device)
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.hra_u.keys():
+                    continue
+                delta_weight = self.get_delta_weight(active_adapter)
+                new_weight = torch.mm(new_weight, delta_weight)
+            x = x.to(self.base_layer.weight.data.dtype)
+            orig_weight = self.base_layer.weight.data
+            orig_weight = orig_weight.view(self.out_features, self.in_features * self.base_layer.kernel_size[0] * self.base_layer.kernel_size[0])
+            new_weight = torch.mm(orig_weight, new_weight)
+            new_weight = new_weight.view(self.out_features, self.in_features, self.base_layer.kernel_size[0], self.base_layer.kernel_size[0])
+            result = F.conv2d(input=x, weight=new_weight, bias=self.base_layer.bias, padding=self.base_layer.padding[0], stride=self.base_layer.stride[0])
+        result = result.to(previous_dtype)
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return 'hra.' + rep
+
+# File: peft-main/src/peft/tuners/hra/model.py
+import warnings
+from dataclasses import asdict
+from enum import Enum
+from typing import List, Optional
+import torch
+from torch import nn
+from tqdm import tqdm
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer, check_target_module_exists
+from peft.utils import TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING, ModulesToSaveWrapper, _get_submodules
+from .config import HRAConfig
+from .layer import HRAConv2d, HRALayer, HRALinear
+
+class HRAModel(BaseTuner):
+    prefix: str = 'hra_'
+
+    def _check_new_adapter_config(self, config: HRAConfig) -> None:
+        if len(self.peft_config) > 1 and config.bias != 'none':
+            raise ValueError(f"{self.__class__.__name__} supports only 1 adapter with bias. When using multiple adapters, set bias to 'none' for all adapters.")
+
+    @staticmethod
+    def _check_target_module_exists(hra_config, key):
+        return check_target_module_exists(hra_config, key)
+
+    def _create_and_replace(self, hra_config, adapter_name, target, target_name, parent, current_key, **optional_kwargs):
+        if current_key is None:
+            raise ValueError("Current Key shouldn't be `None`")
+        bias = hasattr(target, 'bias') and target.bias is not None
+        kwargs = {'r': hra_config.r, 'apply_GS': hra_config.apply_GS, 'init_weights': hra_config.init_weights}
+        kwargs['bias'] = bias
+        if not isinstance(target, HRALayer):
+            new_module = self._create_new_module(hra_config, adapter_name, target, **kwargs)
+            if adapter_name not in self.active_adapters:
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+        else:
+            target.update_layer(adapter_name, r=hra_config.r, apply_GS=hra_config.apply_GS, init_weights=hra_config.init_weights)
+
+    def _replace_module(self, parent, child_name, new_module, child):
+        setattr(parent, child_name, new_module)
+        if hasattr(child, 'base_layer'):
+            child = child.base_layer
+        if not hasattr(new_module, 'base_layer'):
+            new_module.weight = child.weight
+            if hasattr(child, 'bias'):
+                new_module.bias = child.bias
+        if getattr(child, 'state', None) is not None:
+            if hasattr(new_module, 'base_layer'):
+                new_module.base_layer.state = child.state
+            else:
+                new_module.state = child.state
+            new_module.to(child.weight.device)
+        for (name, module) in new_module.named_modules():
+            if self.prefix in name:
+                module.to(child.weight.device)
+
+    def _mark_only_adapters_as_trainable(self, model: nn.Module) -> None:
+        for (n, p) in model.named_parameters():
+            if self.prefix not in n:
+                p.requires_grad = False
+        for active_adapter in self.active_adapters:
+            bias = self.peft_config[active_adapter].bias
+            if bias == 'none':
+                continue
+            if bias == 'all':
+                for (n, p) in model.named_parameters():
+                    if 'bias' in n:
+                        p.requires_grad = True
+            elif bias == 'hra_only':
+                for (name, m) in model.named_modules():
+                    if isinstance(m, HRALayer) and hasattr(m, 'bias') and (m.bias is not None):
+                        m.bias.requires_grad = True
+            else:
+                raise NotImplementedError(f'Requested bias: {bias}, is not implemented.')
+
+    @staticmethod
+    def _create_new_module(hra_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 = HRALinear(target, adapter_name, **kwargs)
+        elif isinstance(target_base_layer, torch.nn.Conv2d):
+            new_module = HRAConv2d(target, adapter_name, **kwargs)
+        else:
+            raise ValueError(f'Target module {target} is not supported. Currently, only `torch.nn.Linear` and `torch.nn.Conv2d` are supported.')
+        return new_module
+
+    def __getattr__(self, name: str):
+        try:
+            return super().__getattr__(name)
+        except AttributeError:
+            if name == 'base_model':
+                raise
+            return getattr(self.model, name)
+
+    def get_peft_config_as_dict(self, inference: bool=False):
+        config_dict = {}
+        for (key, value) in self.peft_config.items():
+            config = {k: v.value if isinstance(v, Enum) else v for (k, v) in asdict(value).items()}
+            if inference:
+                config['inference_mode'] = True
+        config_dict[key] = config
+        return config
+
+    def _set_adapter_layers(self, enabled=True):
+        for module in self.model.modules():
+            if isinstance(module, (BaseTunerLayer, ModulesToSaveWrapper)):
+                module.enable_adapters(enabled)
+
+    def enable_adapter_layers(self):
+        self._set_adapter_layers(enabled=True)
+
+    def disable_adapter_layers(self):
+        for active_adapter in self.active_adapters:
+            val = self.peft_config[active_adapter].bias
+            if val != 'none':
+                msg = f"Careful, disabling adapter layers with bias configured to be '{val}' does not produce the same output as the the base model would without adaption."
+                warnings.warn(msg)
+        self._set_adapter_layers(enabled=False)
+
+    def set_adapter(self, adapter_name):
+        for module in self.model.modules():
+            if isinstance(module, HRALayer):
+                if module.merged:
+                    warnings.warn('Adapter cannot be set when the model is merged. Unmerging the model first.')
+                    module.unmerge()
+                module.set_adapter(adapter_name)
+        self.active_adapter = adapter_name
+
+    @staticmethod
+    def _prepare_adapter_config(peft_config, model_config):
+        if peft_config.target_modules is None:
+            if model_config['model_type'] not in TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING:
+                raise ValueError('Please specify `target_modules` in `peft_config`')
+            peft_config.target_modules = set(TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING[model_config['model_type']])
+        return peft_config
+
+    def _unload_and_optionally_merge(self, merge=True, progressbar: bool=False, safe_merge: bool=False, adapter_names: Optional[List[str]]=None):
+        self._unloading_checks(adapter_names)
+        key_list = [key for (key, _) in self.model.named_modules() if self.prefix not in key]
+        desc = 'Unloading ' + ('and merging ' if merge else '') + 'model'
+        for key in tqdm(key_list, disable=not progressbar, desc=desc):
+            try:
+                (parent, target, target_name) = _get_submodules(self.model, key)
+            except AttributeError:
+                continue
+            if hasattr(target, 'base_layer'):
+                if merge:
+                    target.merge(safe_merge=safe_merge, adapter_names=adapter_names)
+                self._replace_module(parent, target_name, target.get_base_layer(), target)
+            elif isinstance(target, ModulesToSaveWrapper):
+                setattr(parent, target_name, target.modules_to_save[target.active_adapter])
+        return self.model
+
+    def delete_adapter(self, adapter_name: str) -> None:
+        if adapter_name not in list(self.peft_config.keys()):
+            raise ValueError(f'Adapter {adapter_name} does not exist')
+        del self.peft_config[adapter_name]
+        key_list = [key for (key, _) in self.model.named_modules() if self.prefix not in key]
+        new_adapter = None
+        for key in key_list:
+            (_, target, _) = _get_submodules(self.model, key)
+            if isinstance(target, HRALayer):
+                target.delete_adapter(adapter_name)
+                if new_adapter is None:
+                    new_adapter = target.active_adapters[:]
+        self.active_adapter = new_adapter or []
+
+    def merge_and_unload(self, progressbar: bool=False, safe_merge: bool=False, adapter_names: Optional[List[str]]=None) -> torch.nn.Module:
+        return self._unload_and_optionally_merge(progressbar=progressbar, safe_merge=safe_merge, adapter_names=adapter_names)
+
+    def unload(self) -> torch.nn.Module:
+        return self._unload_and_optionally_merge(merge=False)
+
+# File: peft-main/src/peft/tuners/ia3/__init__.py
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available
+from .config import IA3Config
+from .layer import Conv2d, IA3Layer, Linear
+from .model import IA3Model
+__all__ = ['Conv2d', 'IA3Config', 'IA3Layer', 'IA3Model', 'Linear']
+
+def __getattr__(name):
+    if name == 'Linear8bitLt' and is_bnb_available():
+        from .bnb import Linear8bitLt
+        return Linear8bitLt
+    if name == 'Linear4bit' and is_bnb_4bit_available():
+        from .bnb import Linear4bit
+        return Linear4bit
+    raise AttributeError(f'module {__name__} has no attribute {name}')
+
+# File: peft-main/src/peft/tuners/ia3/bnb.py
+from typing import Any
+import torch
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available
+from .layer import IA3Layer
+if is_bnb_available():
+
+    class Linear8bitLt(torch.nn.Module, IA3Layer):
+
+        def __init__(self, base_layer: torch.nn.Module, adapter_name: str, is_feedforward: bool, init_ia3_weights: bool=True, **kwargs) -> None:
+            super().__init__()
+            IA3Layer.__init__(self, base_layer, is_feedforward=is_feedforward)
+            self.get_base_layer().weight.requires_grad = False
+            self._active_adapter = adapter_name
+            self.update_layer(adapter_name, init_ia3_weights)
+
+        def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+            if self.disable_adapters:
+                return self.base_layer(x)
+            ia3_scaling = 1
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.ia3_l.keys():
+                    continue
+                ia3_scaling *= self.ia3_l[active_adapter].flatten()
+            requires_conversion = not torch.is_autocast_enabled() and x.dtype != torch.float32
+            if requires_conversion:
+                x = x.float()
+            if self.is_feedforward:
+                result = self.base_layer(x * ia3_scaling)
+                expected_dtype = result.dtype
+            else:
+                result = self.base_layer(x)
+                expected_dtype = result.dtype
+                result = result * ia3_scaling
+            if requires_conversion:
+                result = result.to(expected_dtype)
+            return result
+
+        def __repr__(self) -> str:
+            rep = super().__repr__()
+            return 'ia3.' + rep
+if is_bnb_4bit_available():
+
+    class Linear4bit(torch.nn.Module, IA3Layer):
+
+        def __init__(self, base_layer: torch.nn.Module, adapter_name: str, is_feedforward: bool, init_ia3_weights: bool=True, **kwargs) -> None:
+            super().__init__()
+            IA3Layer.__init__(self, base_layer, is_feedforward=is_feedforward)
+            self.get_base_layer().weight.requires_grad = False
+            self._active_adapter = adapter_name
+            self.update_layer(adapter_name, init_ia3_weights)
+
+        def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+            if self.disable_adapters:
+                return self.base_layer(x)
+            ia3_scaling = 1
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.ia3_l.keys():
+                    continue
+                ia3_scaling *= self.ia3_l[active_adapter].flatten()
+            requires_conversion = not torch.is_autocast_enabled() and x.dtype != torch.float32
+            if requires_conversion:
+                x = x.float()
+            if self.is_feedforward:
+                result = self.base_layer(x * ia3_scaling)
+                expected_dtype = result.dtype
+            else:
+                result = self.base_layer(x)
+                expected_dtype = result.dtype
+                result = result * ia3_scaling
+            result = result.clone()
+            if requires_conversion:
+                result = result.to(expected_dtype)
+            return result
+
+        def __repr__(self) -> str:
+            rep = super().__repr__()
+            return 'ia3.' + rep
+
+# File: peft-main/src/peft/tuners/ia3/config.py
+from dataclasses import dataclass, field
+from typing import List, Optional, Union
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+@dataclass
+class IA3Config(PeftConfig):
+    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 (IA)³.For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'.This can also be a wildcard 'all-linear' which matches all linear/Conv1D layers except the output layer.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."})
+    feedforward_modules: Optional[Union[List[str], str]] = field(default=None, metadata={'help': "List of module names or a regex expression of module names which are feedforwardFor example, ['output.dense']"})
+    fan_in_fan_out: bool = field(default=False, metadata={'help': 'Set this to True if the layer to replace stores weight like (fan_in, fan_out)'})
+    modules_to_save: Optional[List[str]] = field(default=None, metadata={'help': 'List of modules apart from (IA)^3 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_ia3_weights: bool = field(default=True, metadata={'help': 'Whether to initialize the vectors in the (IA)^3 layers.'})
+
+    def __post_init__(self):
+        self.peft_type = PeftType.IA3
+        self.target_modules = set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        self.feedforward_modules = set(self.feedforward_modules) if isinstance(self.feedforward_modules, list) else self.feedforward_modules
+        if isinstance(self.feedforward_modules, set) and isinstance(self.target_modules, set):
+            if not self.feedforward_modules.issubset(self.target_modules):
+                raise ValueError('`feedforward_modules` should be a subset of `target_modules`')
+
+# File: peft-main/src/peft/tuners/ia3/layer.py
+import warnings
+from typing import Any, List, Optional
+import torch
+import torch.nn as nn
+from transformers.pytorch_utils import Conv1D
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+from peft.utils import transpose
+
+class IA3Layer(BaseTunerLayer):
+    adapter_layer_names = ('ia3_l',)
+
+    def __init__(self, base_layer: nn.Module, is_feedforward: bool, **kwargs) -> None:
+        self.base_layer = base_layer
+        self.ia3_l = nn.ParameterDict({})
+        self._disable_adapters = False
+        self.merged_adapters = []
+        self.is_feedforward = is_feedforward
+        base_layer = self.get_base_layer()
+        if isinstance(base_layer, nn.Linear):
+            (in_features, out_features) = (base_layer.in_features, base_layer.out_features)
+        elif isinstance(base_layer, nn.Conv2d):
+            (in_features, out_features) = (base_layer.in_channels, base_layer.out_channels)
+        elif isinstance(base_layer, nn.Embedding):
+            (in_features, out_features) = (base_layer.num_embeddings, base_layer.embedding_dim)
+        elif isinstance(base_layer, Conv1D):
+            (in_features, out_features) = base_layer.weight.ds_shape if hasattr(base_layer.weight, 'ds_shape') else base_layer.weight.shape
+        else:
+            raise ValueError(f'Unsupported layer type {type(base_layer)}')
+        self.in_features = in_features
+        self.out_features = out_features
+
+    def update_layer(self, adapter_name, init_ia3_weights):
+        if self.is_feedforward:
+            weight = torch.randn((1, self.in_features))
+        else:
+            weight = torch.randn((self.out_features, 1))
+        self.ia3_l[adapter_name] = nn.Parameter(weight)
+        if init_ia3_weights:
+            self.reset_ia3_parameters(adapter_name)
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters)
+
+    def reset_ia3_parameters(self, adapter_name):
+        if adapter_name in self.ia3_l.keys():
+            nn.init.constant_(self.ia3_l[adapter_name], 1.0)
+
+class Linear(nn.Module, IA3Layer):
+
+    def __init__(self, base_layer: nn.Module, adapter_name: str, fan_in_fan_out: bool=False, is_feedforward: bool=False, is_target_conv_1d_layer: bool=False, init_ia3_weights: bool=True, **kwargs) -> None:
+        super().__init__()
+        IA3Layer.__init__(self, base_layer, is_feedforward=is_feedforward)
+        self.fan_in_fan_out = fan_in_fan_out
+        self.is_target_conv_1d_layer = is_target_conv_1d_layer
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, init_ia3_weights)
+
+    def merge(self, safe_merge: bool=False, adapter_names: Optional[List[str]]=None) -> None:
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            return
+        for active_adapter in adapter_names:
+            if active_adapter in self.ia3_l.keys():
+                base_layer = self.get_base_layer()
+                ia3_l = transpose(self.ia3_l[active_adapter].data, self.fan_in_fan_out)
+                orig_dtype = base_layer.weight.data.dtype
+                if safe_merge:
+                    orig_weights = base_layer.weight.data
+                    orig_weights = torch.mul(orig_weights, ia3_l)
+                    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.to(orig_dtype)
+                else:
+                    base_layer.weight.data = torch.mul(base_layer.weight.data, ia3_l).to(orig_dtype)
+                if not self.is_feedforward and base_layer.bias is not None:
+                    scaling = self.ia3_l[active_adapter].reshape(base_layer.bias.shape)
+                    orig_dtype = base_layer.bias.data.dtype
+                    base_layer.bias.data = torch.mul(base_layer.bias.data, scaling.data).to(orig_dtype)
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        if not self.merged:
+            warnings.warn('Already unmerged. Nothing to do.')
+            return
+        warnings.warn('Unmerge result can be inaccurate for (IA)^3.')
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self.ia3_l.keys():
+                base_layer = self.get_base_layer()
+                ia3_l = transpose(self.ia3_l[active_adapter].data, self.fan_in_fan_out) + 1e-08
+                orig_dtype = base_layer.weight.data.dtype
+                base_layer.weight.data = torch.div(base_layer.weight.data, ia3_l).to(orig_dtype)
+                if not self.is_feedforward and base_layer.bias is not None:
+                    scaling = self.ia3_l[active_adapter].reshape(base_layer.bias.shape)
+                    orig_dtype = base_layer.bias.data.dtype
+                    base_layer.bias.data = torch.div(base_layer.bias.data, scaling.data + 1e-08).to(orig_dtype)
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        dtype = previous_dtype = x.dtype
+        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:
+            ia3_scaling = 1
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.ia3_l.keys():
+                    continue
+                dtype = self.ia3_l[active_adapter].dtype
+                ia3_scaling *= self.ia3_l[active_adapter].flatten()
+            if self.is_feedforward:
+                x = x.to(dtype)
+                interm = (x * ia3_scaling).to(previous_dtype)
+                result = self.base_layer(interm, *args, **kwargs)
+            else:
+                result = self.base_layer(x, *args, **kwargs)
+                result_dtype = result.dtype
+                result = (result * ia3_scaling).to(result_dtype)
+        return result
+
+class Conv2d(nn.Module, IA3Layer):
+
+    def __init__(self, base_layer: nn.Module, adapter_name: str, fan_in_fan_out: bool=False, is_feedforward: bool=False, init_ia3_weights: bool=True, **kwargs) -> None:
+        super().__init__()
+        IA3Layer.__init__(self, base_layer, is_feedforward=is_feedforward)
+        self.fan_in_fan_out = fan_in_fan_out
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, init_ia3_weights)
+
+    def update_layer(self, adapter_name, init_ia3_weights):
+        if self.is_feedforward:
+            weight = torch.randn((1, self.in_features, 1, 1))
+        else:
+            weight = torch.randn((1, self.out_features, 1, 1))
+        self.ia3_l[adapter_name] = nn.Parameter(weight)
+        if init_ia3_weights:
+            self.reset_ia3_parameters(adapter_name)
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters)
+
+    def merge(self, safe_merge: bool=False, adapter_names: Optional[List[str]]=None) -> None:
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            return
+        for active_adapter in adapter_names:
+            if active_adapter in self.ia3_l.keys():
+                base_layer = self.get_base_layer()
+                ia3_scaling = self.ia3_l[active_adapter].data
+                if not self.is_feedforward:
+                    ia3_scaling = ia3_scaling.permute(1, 0, 2, 3)
+                if safe_merge:
+                    output_weight = torch.mul(base_layer.weight.data, ia3_scaling).clone()
+                    if not torch.isfinite(output_weight).all():
+                        raise ValueError(f'NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken')
+                    base_layer.weight.data = output_weight
+                else:
+                    base_layer.weight.data = torch.mul(base_layer.weight.data, ia3_scaling)
+                if not self.is_feedforward and base_layer.bias is not None:
+                    scaling = self.ia3_l[active_adapter].reshape(base_layer.bias.shape)
+                    base_layer.bias.data = torch.mul(base_layer.bias.data, scaling.data)
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        if not self.merged:
+            warnings.warn('Already unmerged. Nothing to do.')
+            return
+        warnings.warn('Unmerge result can be inaccurate for (IA)^3.')
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self.ia3_l.keys():
+                base_layer = self.get_base_layer()
+                ia3_scaling = self.ia3_l[active_adapter].data
+                if not self.is_feedforward:
+                    ia3_scaling = ia3_scaling.permute(1, 0, 2, 3)
+                base_layer.weight.data = torch.div(base_layer.weight.data, ia3_scaling + 1e-08)
+                if not self.is_feedforward and base_layer.bias is not None:
+                    scaling = self.ia3_l[active_adapter].reshape(base_layer.bias.shape)
+                    base_layer.bias.data = torch.mul(base_layer.bias.data, scaling.data)
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        dtype = previous_dtype = x.dtype
+        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:
+            ia3_scaling = 1
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.ia3_l.keys():
+                    continue
+                dtype = self.ia3_l[active_adapter].dtype
+                ia3_scaling *= self.ia3_l[active_adapter]
+            if self.is_feedforward:
+                x = x.to(dtype)
+                interm = (x * ia3_scaling).to(self.get_base_layer().weight.dtype)
+                result = self.base_layer(interm, *args, **kwargs)
+            else:
+                result = self.base_layer(x, *args, **kwargs)
+                result = result.to(dtype) * ia3_scaling
+        result = result.to(previous_dtype)
+        return result
+
+# File: peft-main/src/peft/tuners/ia3/model.py
+from __future__ import annotations
+import re
+import warnings
+from dataclasses import asdict, replace
+from enum import Enum
+from typing import Optional
+import torch
+from torch import nn
+from transformers.pytorch_utils import Conv1D
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer, check_target_module_exists
+from peft.utils import TRANSFORMERS_MODELS_TO_IA3_FEEDFORWARD_MODULES_MAPPING, TRANSFORMERS_MODELS_TO_IA3_TARGET_MODULES_MAPPING, ModulesToSaveWrapper, _freeze_adapter, _get_submodules
+from .layer import Conv2d, IA3Layer, Linear
+
+class IA3Model(BaseTuner):
+    prefix: str = 'ia3_'
+
+    def __init__(self, model, config, adapter_name):
+        super().__init__(model, config, adapter_name)
+
+    @staticmethod
+    def _create_new_module(ia3_config, adapter_name, target, **kwargs):
+        if is_bnb_available():
+            import bitsandbytes as bnb
+            from .bnb import Linear8bitLt
+        if is_bnb_4bit_available():
+            from .bnb import Linear4bit
+        loaded_in_8bit = kwargs.pop('loaded_in_8bit', False)
+        loaded_in_4bit = kwargs.pop('loaded_in_4bit', False)
+        is_feedforward = kwargs.pop('is_feedforward', 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):
+            eightbit_kwargs = kwargs.copy()
+            eightbit_kwargs.update({'has_fp16_weights': target_base_layer.state.has_fp16_weights, 'memory_efficient_backward': target_base_layer.state.memory_efficient_backward, 'threshold': target_base_layer.state.threshold, 'index': target_base_layer.index})
+            new_module = Linear8bitLt(target, adapter_name, is_feedforward=is_feedforward, **eightbit_kwargs)
+        elif loaded_in_4bit 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 = Linear4bit(target, adapter_name, is_feedforward=is_feedforward, **fourbit_kwargs)
+        elif isinstance(target, torch.nn.Conv2d):
+            new_module = Conv2d(target, adapter_name, is_feedforward=is_feedforward, **kwargs)
+        elif isinstance(target_base_layer, torch.nn.Linear):
+            if kwargs['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.')
+                kwargs['fan_in_fan_out'] = ia3_config.fan_in_fan_out = False
+            new_module = Linear(target, adapter_name, is_feedforward=is_feedforward, **kwargs)
+        elif isinstance(target_base_layer, Conv1D):
+            if not kwargs['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.')
+                kwargs['fan_in_fan_out'] = ia3_config.fan_in_fan_out = True
+            new_module = Linear(target, adapter_name, is_feedforward=is_feedforward, is_target_conv_1d_layer=True, **kwargs)
+        else:
+            raise ValueError(f'Target module {target} is not supported. Currently, only `torch.nn.Linear`, `torch.nn.Conv2d`, and `Conv1D` are supported.')
+        return new_module
+
+    @staticmethod
+    def _check_target_module_exists(ia3_config, key):
+        return check_target_module_exists(ia3_config, key)
+
+    def _mark_only_adapters_as_trainable(self, model: nn.Module) -> None:
+        for (n, p) in model.named_parameters():
+            if self.prefix not in n:
+                p.requires_grad = False
+
+    def _create_and_replace(self, ia3_config, adapter_name, target, target_name, parent, current_key):
+        is_feedforward = self._check_target_module_feedforward(ia3_config, current_key)
+        kwargs = {'fan_in_fan_out': ia3_config.fan_in_fan_out, 'init_ia3_weights': ia3_config.init_ia3_weights, 'is_feedforward': is_feedforward, 'loaded_in_8bit': getattr(self.model, 'is_loaded_in_8bit', False), 'loaded_in_4bit': getattr(self.model, 'is_loaded_in_4bit', False)}
+        if isinstance(target, IA3Layer):
+            target.update_layer(adapter_name, ia3_config.init_ia3_weights)
+        else:
+            new_module = self._create_new_module(ia3_config, adapter_name, target, **kwargs)
+            if adapter_name not in self.active_adapters:
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+
+    @staticmethod
+    def _check_target_module_feedforward(ia3_config, key) -> bool:
+        if isinstance(ia3_config.feedforward_modules, str):
+            is_feedforward = bool(re.fullmatch(ia3_config.feedforward_modules, key))
+        else:
+            is_feedforward = any((key.endswith(target_key) for target_key in ia3_config.feedforward_modules))
+        return is_feedforward
+
+    def _replace_module(self, parent, child_name, new_module, child):
+        setattr(parent, child_name, new_module)
+        if hasattr(child, 'base_layer'):
+            child = child.base_layer
+        if not hasattr(new_module, 'base_layer'):
+            new_module.weight = child.weight
+            if hasattr(child, 'bias'):
+                new_module.bias = child.bias
+        if getattr(child, 'state', None) is not None:
+            if hasattr(new_module, 'base_layer'):
+                new_module.base_layer.state = child.state
+            else:
+                new_module.state = child.state
+            new_module.to(child.weight.device)
+        for (name, module) in new_module.named_modules():
+            if self.prefix in name:
+                module.to(child.weight.device)
+
+    def __getattr__(self, name: str):
+        try:
+            return super().__getattr__(name)
+        except AttributeError:
+            if name == 'model':
+                raise
+            return getattr(self.model, name)
+
+    def get_peft_config_as_dict(self, inference: bool=False):
+        config_dict = {}
+        for (key, value) in self.peft_config.items():
+            config = {k: v.value if isinstance(v, Enum) else v for (k, v) in asdict(value).items()}
+            if inference:
+                config['inference_mode'] = True
+        config_dict[key] = config
+        return config
+
+    def _set_adapter_layers(self, enabled=True):
+        for module in self.model.modules():
+            if isinstance(module, (IA3Layer, ModulesToSaveWrapper)):
+                module.enable_adapters(enabled)
+
+    def enable_adapter_layers(self) -> None:
+        self._set_adapter_layers(enabled=True)
+
+    def disable_adapter_layers(self) -> None:
+        self._set_adapter_layers(enabled=False)
+
+    def set_adapter(self, adapter_name: str | list[str]) -> None:
+        for module in self.model.modules():
+            if isinstance(module, IA3Layer):
+                if module.merged:
+                    warnings.warn('Adapter cannot be set when the model is merged. Unmerging the model first.')
+                    module.unmerge()
+                module.set_adapter(adapter_name)
+        self.active_adapter = adapter_name
+
+    @staticmethod
+    def _prepare_adapter_config(peft_config, model_config):
+        if peft_config.target_modules is None:
+            if model_config['model_type'] not in TRANSFORMERS_MODELS_TO_IA3_TARGET_MODULES_MAPPING:
+                raise ValueError('Please specify `target_modules` in `peft_config`')
+            peft_config.target_modules = set(TRANSFORMERS_MODELS_TO_IA3_TARGET_MODULES_MAPPING[model_config['model_type']])
+        if peft_config.feedforward_modules is None:
+            if model_config['model_type'] not in TRANSFORMERS_MODELS_TO_IA3_FEEDFORWARD_MODULES_MAPPING:
+                raise ValueError('Please specify `feedforward_modules` in `peft_config`')
+            peft_config.feedforward_modules = set(TRANSFORMERS_MODELS_TO_IA3_FEEDFORWARD_MODULES_MAPPING[model_config['model_type']])
+        return peft_config
+
+    def _unload_and_optionally_merge(self, merge: bool=True, safe_merge: bool=False, adapter_names: Optional[list[str]]=None):
+        if getattr(self.model, 'is_loaded_in_8bit', False):
+            raise ValueError('Cannot merge ia3 layers when the model is loaded in 8-bit mode')
+        if getattr(self.model, 'is_loaded_in_4bit', False):
+            raise ValueError('Cannot merge ia3 layers when the model is loaded in 4-bit mode')
+        self._unloading_checks(adapter_names)
+        key_list = [key for (key, _) in self.model.named_modules() if self.prefix not in key]
+        for key in key_list:
+            try:
+                (parent, target, target_name) = _get_submodules(self.model, key)
+            except AttributeError:
+                continue
+            if hasattr(target, 'base_layer'):
+                if merge:
+                    target.merge(safe_merge=safe_merge, adapter_names=adapter_names)
+                self._replace_module(parent, target_name, target.get_base_layer(), target)
+            elif isinstance(target, ModulesToSaveWrapper):
+                new_module = target.modules_to_save[target.active_adapter]
+                if hasattr(new_module, 'base_layer'):
+                    if merge:
+                        new_module.merge(safe_merge=safe_merge, adapter_names=adapter_names)
+                    new_module = new_module.get_base_layer()
+                setattr(parent, target_name, new_module)
+        return self.model
+
+    def merge_and_unload(self, safe_merge: bool=False, adapter_names: Optional[list[str]]=None) -> torch.nn.Module:
+        return self._unload_and_optionally_merge(safe_merge=safe_merge, adapter_names=adapter_names)
+
+    def unload(self) -> torch.nn.Module:
+        return self._unload_and_optionally_merge(merge=False)
+
+    def delete_adapter(self, adapter_name: str) -> None:
+        if adapter_name not in self.peft_config:
+            raise ValueError(f'Adapter {adapter_name} does not exist')
+        del self.peft_config[adapter_name]
+        key_list = [key for (key, _) in self.model.named_modules() if self.prefix not in key]
+        new_adapter = None
+        for key in key_list:
+            (_, target, _) = _get_submodules(self.model, key)
+            if isinstance(target, IA3Layer):
+                target.delete_adapter(adapter_name)
+                if new_adapter is None:
+                    new_adapter = target.active_adapters[:]
+        self.active_adapter = new_adapter or []
+
+    def _check_add_weighted_adapter(self, adapters: list[str]) -> tuple[str, str]:
+        for adapter in adapters:
+            if adapter not in self.peft_config:
+                raise ValueError(f'Adapter {adapter} does not exist')
+        modules_to_save_wrappers = [module for module in self.modules() if isinstance(module, ModulesToSaveWrapper)]
+        if any((sum((adapter in wrapper.modules_to_save for adapter in adapters)) > 1 for wrapper in modules_to_save_wrappers)):
+            raise ValueError('Cannot add weighted adapters targeting the same module with modules_to_save.')
+        target_module_types = {type(self.peft_config[adapter].target_modules) for adapter in adapters}
+        feedforward_module_types = {type(self.peft_config[adapter].feedforward_modules) for adapter in adapters}
+        if len(target_module_types) > 1 or len(feedforward_module_types) > 1:
+            raise ValueError('All adapter configs should have the same type for target and feedforward modules.')
+        if str in target_module_types:
+            new_target_modules = '|'.join((f'({self.peft_config[adapter].target_modules})' for adapter in adapters))
+        else:
+            new_target_modules = set.union(*(self.peft_config[adapter].target_modules for adapter in adapters))
+        if str in feedforward_module_types:
+            new_feedforward_modules = '|'.join((f'({self.peft_config[adapter].feedforward_modules})' for adapter in adapters))
+        else:
+            new_feedforward_modules = set.union(*(self.peft_config[adapter].feedforward_modules for adapter in adapters))
+        return (new_target_modules, new_feedforward_modules)
+
+    def add_weighted_adapter(self, adapters: list[str], weights: list[float], adapter_name: str) -> None:
+        if adapter_name in list(self.peft_config.keys()):
+            return
+        (new_target_modules, new_feedforward_modules) = self._check_add_weighted_adapter(adapters=adapters)
+        self.peft_config[adapter_name] = replace(self.peft_config[adapters[0]], target_modules=new_target_modules, feedforward_modules=new_feedforward_modules)
+        self.inject_adapter(self.model, adapter_name)
+        _freeze_adapter(self.model, adapter_name)
+        key_list = [key for (key, _) in self.model.named_modules() if self.prefix not in key]
+        for key in key_list:
+            (_, target, _) = _get_submodules(self.model, key)
+            if isinstance(target, IA3Layer):
+                if adapter_name in target.ia3_l:
+                    target_ia3_l = target.ia3_l[adapter_name]
+                else:
+                    continue
+                target_ia3_l.data = target_ia3_l.data.zero_()
+                for (adapter, weight) in zip(adapters, weights):
+                    if adapter in target.ia3_l:
+                        current_adapter_ia3_l = target.ia3_l[adapter]
+                    else:
+                        continue
+                    target_ia3_l.data += current_adapter_ia3_l.data * weight
+
+# File: peft-main/src/peft/tuners/ln_tuning/config.py
+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 LNTuningConfig(PeftConfig):
+    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 LNTuning.For example, '.*decoder.*' or '.*encoder.*'. 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 shoud specify the target modules manually."})
+    modules_to_save: Optional[Union[list[str], str]] = field(default=None, metadata={'help': 'List of 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.'})
+
+    def __post_init__(self):
+        self.peft_type = PeftType.LN_TUNING
+
+# File: peft-main/src/peft/tuners/ln_tuning/layer.py
+import warnings
+from copy import deepcopy
+from typing import List, Optional
+import torch
+import torch.nn as nn
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+
+class LNTuningLayer(nn.Module, BaseTunerLayer):
+    adapter_layer_names = ('ln_tuning_layers',)
+
+    def __init__(self, base_layer: nn.Module, adapter_name: str):
+        super().__init__()
+        self.base_layer = base_layer
+        self.ln_tuning_layers = nn.ModuleDict({})
+        self.update_layer(self.base_layer, adapter_name)
+        self._active_adapter = adapter_name
+        self.merged_adapters = []
+
+    def update_layer(self, layer: nn.Module, adapter_name: str):
+        self.ln_tuning_layers[adapter_name] = deepcopy(layer)
+
+    def enable_adapters(self, enabled: bool) -> None:
+        if enabled:
+            self.set_adapter(self.active_adapters)
+            self._disable_adapters = False
+        else:
+            if self.merged:
+                self.unmerge()
+            for layer_name in self.adapter_layer_names:
+                layer = getattr(self, layer_name)
+                layer.requires_grad_(False)
+            self._disable_adapters = True
+
+    def merge(self, adapter_names: Optional[List[str]]=None):
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            return
+        if len(adapter_names) > 1:
+            raise ValueError(f'Trying to merge {len(adapter_names)} adapters, but LN tuning does not allow merging more than one adapter at a time')
+        merged_adapters = set(self.merged_adapters)
+        if merged_adapters:
+            warnings.warn(f'Already merged with {merged_adapters}. Unmerging first.')
+            self.unmerge()
+        (self.base_layer, self.ln_tuning_layers[adapter_names[0]]) = (self.ln_tuning_layers[adapter_names[0]], self.base_layer)
+        self.merged_adapters.append(adapter_names[0])
+
+    def unmerge(self):
+        if not self.merged:
+            warnings.warn('Already unmerged. Nothing to do.')
+            return
+        merged_name = self.merged_adapters.pop()
+        (self.base_layer, self.ln_tuning_layers[merged_name]) = (self.ln_tuning_layers[merged_name], self.base_layer)
+
+    def forward(self, x: torch.Tensor, *args, **kwargs) -> 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:
+            if len(self.active_adapters) != 1:
+                raise ValueError(f'Trying to run forward with {len(self.active_adapters)} active adapters, but LN tuning does not allow inference with more than one adapter at a time')
+            active_adapter = self.active_adapters[0]
+            result = self.ln_tuning_layers[active_adapter](x, *args, **kwargs)
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return 'ln_tuning.' + rep
+
+# File: peft-main/src/peft/tuners/ln_tuning/model.py
+from __future__ import annotations
+import warnings
+from typing import Optional
+from torch import nn
+from torch.nn.modules import Module
+from tqdm import tqdm
+from peft.config import PeftConfig
+from peft.tuners.tuners_utils import BaseTuner, _get_submodules, check_target_module_exists
+from peft.utils import TRANSFORMERS_MODELS_TO_LNTUNING_TARGET_MODULES_MAPPING, ModulesToSaveWrapper
+from .layer import LNTuningLayer
+
+class LNTuningModel(BaseTuner):
+    prefix: str = 'ln_tuning_'
+
+    def __init__(self, model, config, adapter_name) -> None:
+        super().__init__(model, config, adapter_name)
+
+    def __getattr__(self, name: str):
+        try:
+            return super().__getattr__(name)
+        except AttributeError:
+            if name == 'model':
+                raise
+            return getattr(self.model, name)
+
+    @staticmethod
+    def _prepare_adapter_config(peft_config: PeftConfig, model_config: dict) -> PeftConfig:
+        if peft_config.target_modules is None:
+            if model_config['model_type'] not in TRANSFORMERS_MODELS_TO_LNTUNING_TARGET_MODULES_MAPPING:
+                raise ValueError('Please specify `target_modules` in `peft_config`')
+            peft_config.target_modules = set(TRANSFORMERS_MODELS_TO_LNTUNING_TARGET_MODULES_MAPPING[model_config['model_type']])
+        return peft_config
+
+    def _create_and_replace(self, peft_config: PeftConfig, adapter_name: str, target: Module, target_name: str, parent: Module, current_key: str) -> None:
+        new_module = self._create_new_module(peft_config, target, adapter_name)
+        if adapter_name != self.active_adapter:
+            new_module.requires_grad_(False)
+        self._replace_module(parent, target_name, new_module, target)
+
+    def _create_new_module(self, peft_config: PeftConfig, target: Module, adapter_name: str) -> Module:
+        if not isinstance(target, LNTuningLayer):
+            new_module = LNTuningLayer(target, adapter_name)
+        else:
+            new_module = target
+            new_module.update_layer(target.base_layer, adapter_name)
+        return new_module
+
+    def _replace_module(self, parent: Module, child_name: str, new_module: Module, child: Module) -> None:
+        setattr(parent, child_name, new_module)
+        if hasattr(child, 'base_layer'):
+            child = child.base_layer
+        if getattr(child, 'state', None) is not None:
+            if hasattr(new_module, 'base_layer'):
+                new_module.base_layer.state = child.state
+            else:
+                new_module.state = child.state
+            new_module.to(child.weight.device)
+        for (name, module) in new_module.named_modules():
+            weight = child.qweight if hasattr(child, 'qweight') else child.weight
+            module.to(weight.device)
+
+    def _mark_only_adapters_as_trainable(self, model: Module):
+        for (n, p) in model.named_parameters():
+            if self.prefix not in n:
+                p.requires_grad = False
+            else:
+                p.requires_grad = True
+
+    def _check_target_module_exists(self, peft_config: PeftConfig, key: str) -> bool:
+        return check_target_module_exists(peft_config, key)
+
+    def _set_adapter_layers(self, enabled: bool) -> None:
+        for module in self.model.modules():
+            if isinstance(module, (LNTuningLayer, ModulesToSaveWrapper)):
+                module.enable_adapters(enabled)
+
+    def enable_adapter_layers(self) -> None:
+        self._set_adapter_layers(enabled=True)
+
+    def disable_adapter_layers(self) -> None:
+        self._set_adapter_layers(enabled=False)
+
+    def set_adapter(self, adapter_name: str) -> None:
+        for module in self.model.modules():
+            if isinstance(module, LNTuningLayer):
+                if module.merged:
+                    warnings.warn('Adapter cannot be set when the model is merged. Unmerging the model first.')
+                    module.unmerge()
+                module.set_adapter(adapter_name)
+        self.active_adapter = adapter_name
+
+    def _unload_and_optionally_merge(self, merge=True, progressbar: bool=False, safe_merge: bool=False, adapter_names: Optional[list[str]]=None):
+        self._unloading_checks(adapter_names)
+        key_list = [key for (key, _) in self.model.named_modules() if self.prefix not in key]
+        desc = 'Unloading adapters ' + ('and merging ' if merge else '') + 'model'
+        for key in tqdm(key_list, disable=not progressbar, desc=desc):
+            try:
+                (parent, target, target_name) = _get_submodules(self.model, key)
+            except AttributeError:
+                continue
+            if hasattr(target, 'base_layer'):
+                if merge:
+                    target.merge(adapter_names)
+                self._replace_module(parent, target_name, target.get_base_layer(), target)
+        return self.model
+
+    def unload(self):
+        return self._unload_and_optionally_merge(merge=False)
+
+    def merge_and_unload(self, progressbar: bool=False, safe_merge: bool=False, adapter_names: Optional[list[str]]=None) -> nn.Module:
+        return self._unload_and_optionally_merge(merge=True)
+
+# File: peft-main/src/peft/tuners/loha/config.py
+from dataclasses import dataclass, field
+from typing import List, Optional, Union
+from peft.tuners.lycoris_utils import LycorisConfig
+from peft.utils import PeftType
+
+@dataclass
+class LoHaConfig(LycorisConfig):
+    r: int = field(default=8, metadata={'help': 'LoHa rank'})
+    alpha: int = field(default=8, metadata={'help': 'LoHa alpha'})
+    rank_dropout: float = field(default=0.0, metadata={'help': 'The dropout probability for rank dimension during training'})
+    module_dropout: float = field(default=0.0, metadata={'help': 'The dropout probability for disabling LoHa modules during training'})
+    use_effective_conv2d: bool = field(default=False, metadata={'help': 'Use parameter effective decomposition for Conv2d 3x3 with ksize > 1 ("Proposition 3" from FedPara paper)'})
+    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 LoHa.For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$' This can also be a wildcard 'all-linear' which matches all linear/Conv1D layers except the output layer."})
+    init_weights: bool = field(default=True, metadata={'help': "Whether to initialize the weights of the LoHa layers with their default initialization. Don't change this setting, except if you know exactly what you're doing."})
+    layers_to_transform: Optional[Union[List[int], int]] = field(default=None, metadata={'help': 'The layer indexes to transform, is this argument is specified, PEFT will transform only the layers indexes that are specified inside this list. If a single integer is passed, PEFT will transform only the layer at this index.'})
+    layers_pattern: Optional[str] = field(default=None, metadata={'help': 'The layer pattern name, used only if `layers_to_transform` is different to None and if the layer pattern is not in the common layers pattern.'})
+    modules_to_save: Optional[List[str]] = field(default=None, metadata={'help': 'List of modules apart from LoHA 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.'})
+
+    def __post_init__(self):
+        self.peft_type = PeftType.LOHA
+        self.target_modules = set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+
+# File: peft-main/src/peft/tuners/loha/layer.py
+import math
+from typing import Any, Set, Tuple
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from peft.tuners.lycoris_utils import LycorisLayer
+
+class LoHaLayer(nn.Module, LycorisLayer):
+    adapter_layer_names = ('hada_w1_a', 'hada_w1_b', 'hada_w2_a', 'hada_w2_b', 'hada_t1', 'hada_t2')
+
+    def __init__(self, base_layer: nn.Module):
+        super().__init__()
+        LycorisLayer.__init__(self, base_layer)
+        self.hada_w1_a = nn.ParameterDict({})
+        self.hada_w1_b = nn.ParameterDict({})
+        self.hada_w2_a = nn.ParameterDict({})
+        self.hada_w2_b = nn.ParameterDict({})
+        self.hada_t1 = nn.ParameterDict({})
+        self.hada_t2 = nn.ParameterDict({})
+
+    @property
+    def _available_adapters(self) -> Set[str]:
+        return {*self.hada_w1_a, *self.hada_w1_b, *self.hada_w2_a, *self.hada_w2_b, *self.hada_t1, *self.hada_t2}
+
+    def create_adapter_parameters(self, adapter_name: str, r: int, shape: Tuple[int, ...]):
+        if len(shape) == 4:
+            self.hada_t1[adapter_name] = nn.Parameter(torch.empty(r, r, shape[2], shape[3]))
+            self.hada_w1_a[adapter_name] = nn.Parameter(torch.empty(r, shape[0]))
+            self.hada_w1_b[adapter_name] = nn.Parameter(torch.empty(r, shape[1]))
+            self.hada_t2[adapter_name] = nn.Parameter(torch.empty(r, r, shape[2], shape[3]))
+            self.hada_w2_a[adapter_name] = nn.Parameter(torch.empty(r, shape[0]))
+            self.hada_w2_b[adapter_name] = nn.Parameter(torch.empty(r, shape[1]))
+        else:
+            self.hada_w1_a[adapter_name] = nn.Parameter(torch.empty(shape[0], r))
+            self.hada_w1_b[adapter_name] = nn.Parameter(torch.empty(r, shape[1]))
+            self.hada_w2_a[adapter_name] = nn.Parameter(torch.empty(shape[0], r))
+            self.hada_w2_b[adapter_name] = nn.Parameter(torch.empty(r, shape[1]))
+
+    def reset_adapter_parameters(self, adapter_name: str):
+        if adapter_name in self.hada_w1_a.keys():
+            nn.init.kaiming_uniform_(self.hada_w1_a[adapter_name], a=math.sqrt(5))
+            nn.init.kaiming_uniform_(self.hada_w1_b[adapter_name], a=math.sqrt(5))
+            nn.init.kaiming_uniform_(self.hada_w2_a[adapter_name], a=math.sqrt(5))
+            nn.init.zeros_(self.hada_w2_b[adapter_name])
+        if adapter_name in self.hada_t1.keys():
+            nn.init.kaiming_uniform_(self.hada_t1[adapter_name], a=math.sqrt(5))
+            nn.init.kaiming_uniform_(self.hada_t2[adapter_name], a=math.sqrt(5))
+
+    def reset_adapter_parameters_random(self, adapter_name: str):
+        if adapter_name in self.hada_w1_a.keys():
+            nn.init.kaiming_uniform_(self.hada_w1_a[adapter_name], a=math.sqrt(5))
+            nn.init.kaiming_uniform_(self.hada_w1_b[adapter_name], a=math.sqrt(5))
+            nn.init.kaiming_uniform_(self.hada_w2_a[adapter_name], a=math.sqrt(5))
+            nn.init.kaiming_uniform_(self.hada_w2_b[adapter_name], a=math.sqrt(5))
+        if adapter_name in self.hada_t1.keys():
+            nn.init.kaiming_uniform_(self.hada_t1[adapter_name], a=math.sqrt(5))
+            nn.init.kaiming_uniform_(self.hada_t2[adapter_name], a=math.sqrt(5))
+
+    def update_layer(self, adapter_name: str, r: int, alpha: float, rank_dropout: float, module_dropout: float, init_weights: bool, use_effective_conv2d: bool=False, **kwargs) -> None:
+        if r <= 0:
+            raise ValueError(f'`r` should be a positive integer value but the value passed is {r}')
+        self.r[adapter_name] = r
+        self.alpha[adapter_name] = alpha
+        self.scaling[adapter_name] = alpha / r
+        self.rank_dropout[adapter_name] = rank_dropout
+        self.module_dropout[adapter_name] = module_dropout
+        base_layer = self.get_base_layer()
+        if isinstance(base_layer, nn.Linear):
+            shape = tuple(base_layer.weight.shape)
+        elif isinstance(base_layer, nn.Conv2d):
+            use_effective_conv2d = use_effective_conv2d and base_layer.kernel_size != (1, 1)
+            if use_effective_conv2d:
+                shape = (base_layer.out_channels, base_layer.in_channels, *base_layer.kernel_size)
+            else:
+                shape = (base_layer.out_channels, base_layer.in_channels * base_layer.kernel_size[0] * base_layer.kernel_size[1])
+        else:
+            raise TypeError(f'LoHa is not implemented for base layers of type {type(base_layer).__name__}')
+        self.create_adapter_parameters(adapter_name, r, shape)
+        if init_weights:
+            self.reset_adapter_parameters(adapter_name)
+        else:
+            self.reset_adapter_parameters_random(adapter_name)
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters)
+
+    def get_delta_weight(self, adapter_name: str) -> torch.Tensor:
+        if adapter_name in self.hada_t1.keys():
+            weight = make_weight_cp(self.hada_t1[adapter_name], self.hada_w1_a[adapter_name], self.hada_w1_b[adapter_name], self.hada_t2[adapter_name], self.hada_w2_a[adapter_name], self.hada_w2_b[adapter_name], scale=torch.tensor(self.scaling[adapter_name]))
+        else:
+            weight = make_weight(self.hada_w1_a[adapter_name], self.hada_w1_b[adapter_name], self.hada_w2_a[adapter_name], self.hada_w2_b[adapter_name], scale=torch.tensor(self.scaling[adapter_name]))
+        base_layer = self.get_base_layer()
+        weight = weight.reshape(base_layer.weight.shape)
+        rank_dropout = self.rank_dropout[adapter_name]
+        if self.training and rank_dropout:
+            drop = (torch.rand(weight.size(0)) > rank_dropout).to(weight.dtype)
+            drop = drop.view(-1, *[1] * len(weight.shape[1:])).to(weight.device)
+            drop /= drop.mean()
+            weight *= drop
+        return weight
+
+    def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+        previous_dtype = x.dtype
+        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._available_adapters:
+                    continue
+                module_dropout = self.module_dropout[active_adapter]
+                if not self.training or (self.training and torch.rand(1) > module_dropout):
+                    result = result + self._get_delta_activations(active_adapter, x, *args, **kwargs)
+        result = result.to(previous_dtype)
+        return result
+
+class Linear(LoHaLayer):
+
+    def __init__(self, base_layer: nn.Module, adapter_name: str='default', r: int=0, alpha: float=0.0, rank_dropout: float=0.0, module_dropout: float=0.0, init_weights: bool=True, **kwargs):
+        super().__init__(base_layer)
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, alpha, rank_dropout, module_dropout, init_weights, **kwargs)
+
+    def _get_delta_activations(self, adapter_name: str, input: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        delta_weight = self.get_delta_weight(adapter_name)
+        return F.linear(input, delta_weight)
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return 'loha.' + rep
+
+class Conv2d(LoHaLayer):
+
+    def __init__(self, base_layer: nn.Module, adapter_name: str='default', r: int=0, alpha: float=0.0, rank_dropout: float=0.0, module_dropout: float=0.0, use_effective_conv2d: bool=False, init_weights: bool=True, **kwargs):
+        super().__init__(base_layer)
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, alpha, rank_dropout, module_dropout, init_weights, use_effective_conv2d, **kwargs)
+
+    def _get_delta_activations(self, adapter_name: str, input: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        delta_weight = self.get_delta_weight(adapter_name)
+        base_layer = self.get_base_layer()
+        return F.conv2d(input, delta_weight, stride=base_layer.stride, padding=base_layer.padding, dilation=base_layer.dilation, groups=base_layer.groups)
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return 'loha.' + rep
+
+class HadaWeight(torch.autograd.Function):
+
+    @staticmethod
+    def forward(ctx, w1a, w1b, w2a, w2b, scale=torch.tensor(1)):
+        ctx.save_for_backward(w1a, w1b, w2a, w2b, scale)
+        diff_weight = w1a @ w1b * (w2a @ w2b) * scale
+        return diff_weight
+
+    @staticmethod
+    def backward(ctx, grad_out):
+        (w1a, w1b, w2a, w2b, scale) = ctx.saved_tensors
+        grad_out = grad_out * scale
+        temp = grad_out * (w2a @ w2b)
+        grad_w1a = temp @ w1b.T
+        grad_w1b = w1a.T @ temp
+        temp = grad_out * (w1a @ w1b)
+        grad_w2a = temp @ w2b.T
+        grad_w2b = w2a.T @ temp
+        del temp
+        return (grad_w1a, grad_w1b, grad_w2a, grad_w2b, None)
+
+class HadaWeightCP(torch.autograd.Function):
+
+    @staticmethod
+    def forward(ctx, t1, w1a, w1b, t2, w2a, w2b, scale=torch.tensor(1)):
+        ctx.save_for_backward(t1, w1a, w1b, t2, w2a, w2b, scale)
+        rebuild1 = torch.einsum('i j k l, j r, i p -> p r k l', t1, w1b, w1a)
+        rebuild2 = torch.einsum('i j k l, j r, i p -> p r k l', t2, w2b, w2a)
+        return rebuild1 * rebuild2 * scale
+
+    @staticmethod
+    def backward(ctx, grad_out):
+        (t1, w1a, w1b, t2, w2a, w2b, scale) = ctx.saved_tensors
+        grad_out = grad_out * scale
+        temp = torch.einsum('i j k l, j r -> i r k l', t2, w2b)
+        rebuild = torch.einsum('i j k l, i r -> r j k l', temp, w2a)
+        grad_w = rebuild * grad_out
+        del rebuild
+        grad_w1a = torch.einsum('r j k l, i j k l -> r i', temp, grad_w)
+        grad_temp = torch.einsum('i j k l, i r -> r j k l', grad_w, w1a.T)
+        del grad_w, temp
+        grad_w1b = torch.einsum('i r k l, i j k l -> r j', t1, grad_temp)
+        grad_t1 = torch.einsum('i j k l, j r -> i r k l', grad_temp, w1b.T)
+        del grad_temp
+        temp = torch.einsum('i j k l, j r -> i r k l', t1, w1b)
+        rebuild = torch.einsum('i j k l, i r -> r j k l', temp, w1a)
+        grad_w = rebuild * grad_out
+        del rebuild
+        grad_w2a = torch.einsum('r j k l, i j k l -> r i', temp, grad_w)
+        grad_temp = torch.einsum('i j k l, i r -> r j k l', grad_w, w2a.T)
+        del grad_w, temp
+        grad_w2b = torch.einsum('i r k l, i j k l -> r j', t2, grad_temp)
+        grad_t2 = torch.einsum('i j k l, j r -> i r k l', grad_temp, w2b.T)
+        del grad_temp
+        return (grad_t1, grad_w1a, grad_w1b, grad_t2, grad_w2a, grad_w2b, None)
+
+def make_weight(w1a, w1b, w2a, w2b, scale):
+    return HadaWeight.apply(w1a, w1b, w2a, w2b, scale)
+
+def make_weight_cp(t1, w1a, w1b, t2, w2a, w2b, scale):
+    return HadaWeightCP.apply(t1, w1a, w1b, t2, w2a, w2b, scale)
+
+# File: peft-main/src/peft/tuners/loha/model.py
+import re
+from itertools import chain
+from typing import Dict, Type, Union
+import torch
+from torch import nn
+from peft.tuners.lycoris_utils import LycorisConfig, LycorisTuner
+from .layer import Conv2d, Linear, LoHaLayer
+
+class LoHaModel(LycorisTuner):
+    prefix: str = 'hada_'
+    layers_mapping: Dict[Type[torch.nn.Module], Type[LoHaLayer]] = {torch.nn.Conv2d: Conv2d, torch.nn.Linear: Linear}
+
+    def _create_and_replace(self, config: LycorisConfig, adapter_name: str, target: Union[LoHaLayer, nn.Module], target_name: str, parent: nn.Module, current_key: str) -> None:
+        pattern_keys = list(chain(config.rank_pattern.keys(), config.alpha_pattern.keys()))
+        target_name_key = next(filter(lambda key: re.match(f'(.*\\.)?{key}$', current_key), pattern_keys), target_name)
+        kwargs = config.to_dict()
+        kwargs['r'] = config.rank_pattern.get(target_name_key, config.r)
+        kwargs['alpha'] = config.alpha_pattern.get(target_name_key, config.alpha)
+        if isinstance(target, LoHaLayer):
+            target.update_layer(adapter_name, **kwargs)
+        else:
+            new_module = self._create_new_module(config, adapter_name, target, **kwargs)
+            self._replace_module(parent, target_name, new_module, target)
+
+# File: peft-main/src/peft/tuners/lokr/config.py
+from dataclasses import dataclass, field
+from typing import List, Optional, Union
+from peft.tuners.lycoris_utils import LycorisConfig
+from peft.utils import PeftType
+
+@dataclass
+class LoKrConfig(LycorisConfig):
+    r: int = field(default=8, metadata={'help': 'LoKr rank'})
+    alpha: int = field(default=8, metadata={'help': 'LoKr alpha'})
+    rank_dropout: float = field(default=0.0, metadata={'help': 'The dropout probability for rank dimension during training'})
+    module_dropout: float = field(default=0.0, metadata={'help': 'The dropout probability for disabling LoKr modules during training'})
+    use_effective_conv2d: bool = field(default=False, metadata={'help': 'Use parameter effective decomposition for Conv2d 3x3 with ksize > 1 ("Proposition 3" from FedPara paper)'})
+    decompose_both: bool = field(default=False, metadata={'help': 'Perform rank decomposition of left kronecker product matrix.'})
+    decompose_factor: int = field(default=-1, metadata={'help': 'Kronecker product decomposition factor.'})
+    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 LoKr.For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$' This can also be a wildcard 'all-linear' which matches all linear/Conv1D layers except the output layer."})
+    init_weights: bool = field(default=True, metadata={'help': "Whether to initialize the weights of the LoKr layers with their default initialization. Don't change this setting, except if you know exactly what you're doing."})
+    layers_to_transform: Optional[Union[List[int], int]] = field(default=None, metadata={'help': 'The layer indexes to transform, is this argument is specified, PEFT will transform only the layers indexes that are specified inside this list. If a single integer is passed, PEFT will transform only the layer at this index.'})
+    layers_pattern: Optional[str] = field(default=None, metadata={'help': 'The layer pattern name, used only if `layers_to_transform` is different to None and if the layer pattern is not in the common layers pattern.'})
+    modules_to_save: Optional[List[str]] = field(default=None, metadata={'help': 'List of modules apart from LoKr 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.'})
+
+    def __post_init__(self):
+        self.peft_type = PeftType.LOKR
+
+# File: peft-main/src/peft/tuners/lokr/layer.py
+import math
+from typing import Any, Optional, Set, Tuple, Union
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from peft.tuners.lycoris_utils import LycorisLayer
+
+class LoKrLayer(nn.Module, LycorisLayer):
+    adapter_layer_names = ('lokr_w1', 'lokr_w1_a', 'lokr_w1_b', 'lokr_w2', 'lokr_w2_a', 'lokr_w2_b', 'lokr_t2')
+
+    def __init__(self, base_layer: nn.Module) -> None:
+        super().__init__()
+        LycorisLayer.__init__(self, base_layer)
+        self.lokr_w1 = nn.ParameterDict({})
+        self.lokr_w1_a = nn.ParameterDict({})
+        self.lokr_w1_b = nn.ParameterDict({})
+        self.lokr_w2 = nn.ParameterDict({})
+        self.lokr_w2_a = nn.ParameterDict({})
+        self.lokr_w2_b = nn.ParameterDict({})
+        self.lokr_t2 = nn.ParameterDict({})
+
+    @property
+    def _available_adapters(self) -> Set[str]:
+        return {*self.lokr_w1, *self.lokr_w1_a, *self.lokr_w1_b, *self.lokr_w2, *self.lokr_w2_a, *self.lokr_w2_b, *self.lokr_t2}
+
+    def create_adapter_parameters(self, adapter_name: str, r: int, shape, use_w1: bool, use_w2: bool, use_effective_conv2d: bool):
+        if use_w1:
+            self.lokr_w1[adapter_name] = nn.Parameter(torch.empty(shape[0][0], shape[1][0]))
+        else:
+            self.lokr_w1_a[adapter_name] = nn.Parameter(torch.empty(shape[0][0], r))
+            self.lokr_w1_b[adapter_name] = nn.Parameter(torch.empty(r, shape[1][0]))
+        if len(shape) == 4:
+            if use_w2:
+                self.lokr_w2[adapter_name] = nn.Parameter(torch.empty(shape[0][1], shape[1][1], *shape[2:]))
+            elif use_effective_conv2d:
+                self.lokr_t2[adapter_name] = nn.Parameter(torch.empty(r, r, shape[2], shape[3]))
+                self.lokr_w2_a[adapter_name] = nn.Parameter(torch.empty(r, shape[0][1]))
+                self.lokr_w2_b[adapter_name] = nn.Parameter(torch.empty(r, shape[1][1]))
+            else:
+                self.lokr_w2_a[adapter_name] = nn.Parameter(torch.empty(shape[0][1], r))
+                self.lokr_w2_b[adapter_name] = nn.Parameter(torch.empty(r, shape[1][1] * shape[2] * shape[3]))
+        elif use_w2:
+            self.lokr_w2[adapter_name] = nn.Parameter(torch.empty(shape[0][1], shape[1][1]))
+        else:
+            self.lokr_w2_a[adapter_name] = nn.Parameter(torch.empty(shape[0][1], r))
+            self.lokr_w2_b[adapter_name] = nn.Parameter(torch.empty(r, shape[1][1]))
+
+    def reset_adapter_parameters(self, adapter_name: str):
+        if adapter_name in self.lokr_w1:
+            nn.init.zeros_(self.lokr_w1[adapter_name])
+        else:
+            nn.init.zeros_(self.lokr_w1_a[adapter_name])
+            nn.init.kaiming_uniform_(self.lokr_w1_b[adapter_name], a=math.sqrt(5))
+        if adapter_name in self.lokr_w2:
+            nn.init.kaiming_uniform_(self.lokr_w2[adapter_name], a=math.sqrt(5))
+        else:
+            nn.init.kaiming_uniform_(self.lokr_w2_a[adapter_name], a=math.sqrt(5))
+            nn.init.kaiming_uniform_(self.lokr_w2_b[adapter_name], a=math.sqrt(5))
+        if adapter_name in self.lokr_t2:
+            nn.init.kaiming_uniform_(self.lokr_t2[adapter_name], a=math.sqrt(5))
+
+    def reset_adapter_parameters_random(self, adapter_name: str):
+        if adapter_name in self.lokr_w1:
+            nn.init.kaiming_uniform_(self.lokr_w1[adapter_name], a=math.sqrt(5))
+        else:
+            nn.init.kaiming_uniform_(self.lokr_w1_a[adapter_name], a=math.sqrt(5))
+            nn.init.kaiming_uniform_(self.lokr_w1_b[adapter_name], a=math.sqrt(5))
+        if adapter_name in self.lokr_w2:
+            nn.init.kaiming_uniform_(self.lokr_w2[adapter_name], a=math.sqrt(5))
+        else:
+            nn.init.kaiming_uniform_(self.lokr_w2_a[adapter_name], a=math.sqrt(5))
+            nn.init.kaiming_uniform_(self.lokr_w2_b[adapter_name], a=math.sqrt(5))
+        if adapter_name in self.lokr_t2:
+            nn.init.kaiming_uniform_(self.lokr_t2[adapter_name], a=math.sqrt(5))
+
+    def update_layer(self, adapter_name: str, r: int, alpha: float, rank_dropout: float, module_dropout: float, init_weights: bool, use_effective_conv2d: bool, decompose_both: bool, decompose_factor: int, **kwargs) -> None:
+        if r <= 0:
+            raise ValueError(f'`r` should be a positive integer value but the value passed is {r}')
+        self.r[adapter_name] = r
+        self.alpha[adapter_name] = alpha
+        self.scaling[adapter_name] = alpha / r
+        self.rank_dropout[adapter_name] = rank_dropout
+        self.module_dropout[adapter_name] = module_dropout
+        base_layer = self.get_base_layer()
+        if isinstance(base_layer, nn.Linear):
+            (in_dim, out_dim) = (base_layer.in_features, base_layer.out_features)
+            (in_m, in_n) = factorization(in_dim, decompose_factor)
+            (out_l, out_k) = factorization(out_dim, decompose_factor)
+            shape = ((out_l, out_k), (in_m, in_n))
+            use_w1 = not (decompose_both and r < max(shape[0][0], shape[1][0]) / 2)
+            use_w2 = not r < max(shape[0][1], shape[1][1]) / 2
+            use_effective_conv2d = False
+        elif isinstance(base_layer, nn.Conv2d):
+            (in_dim, out_dim) = (base_layer.in_channels, base_layer.out_channels)
+            k_size = base_layer.kernel_size
+            (in_m, in_n) = factorization(in_dim, decompose_factor)
+            (out_l, out_k) = factorization(out_dim, decompose_factor)
+            shape = ((out_l, out_k), (in_m, in_n), *k_size)
+            use_w1 = not (decompose_both and r < max(shape[0][0], shape[1][0]) / 2)
+            use_w2 = r >= max(shape[0][1], shape[1][1]) / 2
+            use_effective_conv2d = use_effective_conv2d and base_layer.kernel_size != (1, 1)
+        else:
+            raise TypeError(f'LoKr is not implemented for base layers of type {type(base_layer).__name__}')
+        self.create_adapter_parameters(adapter_name, r, shape, use_w1, use_w2, use_effective_conv2d)
+        if init_weights:
+            self.reset_adapter_parameters(adapter_name)
+        else:
+            self.reset_adapter_parameters_random(adapter_name)
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters)
+
+    def get_delta_weight(self, adapter_name: str) -> torch.Tensor:
+        if adapter_name in self.lokr_w1:
+            w1 = self.lokr_w1[adapter_name]
+        else:
+            w1 = self.lokr_w1_a[adapter_name] @ self.lokr_w1_b[adapter_name]
+        if adapter_name in self.lokr_w2:
+            w2 = self.lokr_w2[adapter_name]
+        elif adapter_name in self.lokr_t2:
+            w2 = make_weight_cp(self.lokr_t2[adapter_name], self.lokr_w2_a[adapter_name], self.lokr_w2_b[adapter_name])
+        else:
+            w2 = self.lokr_w2_a[adapter_name] @ self.lokr_w2_b[adapter_name]
+        weight = make_kron(w1, w2)
+        weight = weight.reshape(self.get_base_layer().weight.shape)
+        rank_dropout = self.rank_dropout[adapter_name]
+        if self.training and rank_dropout:
+            drop = (torch.rand(weight.size(0)) > rank_dropout).float()
+            drop = drop.view(-1, *[1] * len(weight.shape[1:])).to(weight.device)
+            drop /= drop.mean()
+            weight *= drop
+        return weight
+
+    def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+        previous_dtype = x.dtype
+        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._available_adapters:
+                    continue
+                module_dropout = self.module_dropout[active_adapter]
+                if not self.training or (self.training and torch.rand(1) > module_dropout):
+                    result = result + self._get_delta_activations(active_adapter, x, *args, **kwargs)
+        result = result.to(previous_dtype)
+        return result
+
+class Linear(LoKrLayer):
+
+    def __init__(self, base_layer: nn.Module, device: Optional[Union[str, torch.device]]=None, dtype: Optional[torch.dtype]=None, adapter_name: str='default', r: int=0, alpha: float=0.0, rank_dropout: float=0.0, module_dropout: float=0.0, init_weights: bool=True, **kwargs):
+        super().__init__(base_layer)
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, alpha, rank_dropout, module_dropout, init_weights, **kwargs)
+
+    def _get_delta_activations(self, adapter_name: str, input: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        delta_weight = self.get_delta_weight(adapter_name)
+        return F.linear(input, delta_weight)
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return 'lokr.' + rep
+
+class Conv2d(LoKrLayer):
+
+    def __init__(self, base_layer: nn.Module, device: Optional[Union[str, torch.device]]=None, dtype: Optional[torch.dtype]=None, adapter_name: str='default', r: int=0, alpha: float=0.0, rank_dropout: float=0.0, module_dropout: float=0.0, use_effective_conv2d: bool=False, init_weights: bool=True, **kwargs):
+        super().__init__(base_layer)
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, alpha, rank_dropout, module_dropout, init_weights, use_effective_conv2d, **kwargs)
+
+    def _get_delta_activations(self, adapter_name: str, input: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        delta_weight = self.get_delta_weight(adapter_name)
+        base_layer = self.get_base_layer()
+        return F.conv2d(input, delta_weight, stride=base_layer.stride, padding=base_layer.padding, dilation=base_layer.dilation, groups=base_layer.groups)
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return 'lokr.' + rep
+
+def factorization(dimension: int, factor: int=-1) -> Tuple[int, int]:
+    if factor > 0 and dimension % factor == 0:
+        m = factor
+        n = dimension // factor
+        return (m, n)
+    if factor == -1:
+        factor = dimension
+    (m, n) = (1, dimension)
+    length = m + n
+    while m < n:
+        new_m = m + 1
+        while dimension % new_m != 0:
+            new_m += 1
+        new_n = dimension // new_m
+        if new_m + new_n > length or new_m > factor:
+            break
+        else:
+            (m, n) = (new_m, new_n)
+    if m > n:
+        (n, m) = (m, n)
+    return (m, n)
+
+def make_weight_cp(t, wa, wb):
+    rebuild2 = torch.einsum('i j k l, i p, j r -> p r k l', t, wa, wb)
+    return rebuild2
+
+def make_kron(w1, w2, scale=1.0):
+    if len(w2.shape) == 4:
+        w1 = w1.unsqueeze(2).unsqueeze(2)
+    w2 = w2.contiguous()
+    rebuild = torch.kron(w1, w2)
+    return rebuild * scale
+
+# File: peft-main/src/peft/tuners/lokr/model.py
+import re
+from itertools import chain
+from typing import Dict, Type, Union
+import torch
+from torch import nn
+from peft.tuners.lycoris_utils import LycorisConfig, LycorisTuner
+from .layer import Conv2d, Linear, LoKrLayer
+
+class LoKrModel(LycorisTuner):
+    prefix: str = 'lokr_'
+    layers_mapping: Dict[Type[torch.nn.Module], Type[LoKrLayer]] = {torch.nn.Conv2d: Conv2d, torch.nn.Linear: Linear}
+
+    def _create_and_replace(self, config: LycorisConfig, adapter_name: str, target: Union[LoKrLayer, nn.Module], target_name: str, parent: nn.Module, current_key: str) -> None:
+        pattern_keys = list(chain(config.rank_pattern.keys(), config.alpha_pattern.keys()))
+        target_name_key = next(filter(lambda key: re.match(f'(.*\\.)?{key}$', current_key), pattern_keys), target_name)
+        kwargs = config.to_dict()
+        kwargs['r'] = config.rank_pattern.get(target_name_key, config.r)
+        kwargs['alpha'] = config.alpha_pattern.get(target_name_key, config.alpha)
+        if isinstance(target, LoKrLayer):
+            target.update_layer(adapter_name, **kwargs)
+        else:
+            new_module = self._create_new_module(config, adapter_name, target, **kwargs)
+            self._replace_module(parent, target_name, new_module, target)
+
+# File: peft-main/src/peft/tuners/lora/__init__.py
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available, is_eetq_available
+from .config import LoftQConfig, LoraConfig, LoraRuntimeConfig
+from .gptq import QuantLinear
+from .layer import Conv2d, Embedding, Linear, LoraLayer
+from .model import LoraModel
+__all__ = ['LoraConfig', 'LoraRuntimeConfig', 'LoftQConfig', 'Conv2d', 'Embedding', 'LoraLayer', 'Linear', 'LoraModel', 'QuantLinear']
+
+def __getattr__(name):
+    if name == 'Linear8bitLt' and is_bnb_available():
+        from .bnb import Linear8bitLt
+        return Linear8bitLt
+    if name == 'Linear4bit' and is_bnb_4bit_available():
+        from .bnb import Linear4bit
+        return Linear4bit
+    if name == 'EetqLoraLinear' and is_eetq_available():
+        from .eetq import EetqLoraLinear
+        return EetqLoraLinear
+    raise AttributeError(f'module {__name__} has no attribute {name}')
+
+# File: peft-main/src/peft/tuners/lora/aqlm.py
+from typing import Any, Optional
+import torch
+from peft.import_utils import is_aqlm_available
+from peft.tuners.lora.layer import LoraLayer
+from peft.tuners.tuners_utils import BaseTunerLayer
+if is_aqlm_available():
+    from aqlm import QuantizedLinear
+
+class AqlmLoraLinear(torch.nn.Module, LoraLayer):
+
+    def __init__(self, base_layer, adapter_name: str, r: int=0, lora_alpha: int=1, lora_dropout: float=0.0, init_lora_weights: bool=True, use_rslora: bool=False, **kwargs):
+        super().__init__()
+        LoraLayer.__init__(self, base_layer)
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, lora_alpha, lora_dropout, init_lora_weights, use_rslora)
+
+    def forward(self, x: torch.Tensor):
+        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
+            lora_A = self.lora_A[active_adapter]
+            lora_B = self.lora_B[active_adapter]
+            dropout = self.lora_dropout[active_adapter]
+            scaling = self.scaling[active_adapter]
+            requires_conversion = not torch.is_autocast_enabled()
+            if requires_conversion:
+                expected_dtype = result.dtype
+                x = x.to(lora_A.weight.dtype)
+            output = lora_B(lora_A(dropout(x)))
+            if requires_conversion:
+                output = output.to(expected_dtype)
+            output = output * scaling
+            result += output
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return 'lora.' + rep
+
+def dispatch_aqlm(target: torch.nn.Module, adapter_name: str, **kwargs: Any) -> Optional[torch.nn.Module]:
+    new_module = None
+    if isinstance(target, BaseTunerLayer):
+        target_base_layer = target.get_base_layer()
+    else:
+        target_base_layer = target
+    if is_aqlm_available() and isinstance(target_base_layer, QuantizedLinear):
+        new_module = AqlmLoraLinear(target, adapter_name, **kwargs)
+        target.qweight = target_base_layer.codes
+    return new_module
+
+# File: peft-main/src/peft/tuners/lora/awq.py
+import importlib.metadata as importlib_metadata
+from typing import Any, Optional
+import packaging.version
+import torch
+from peft.import_utils import is_auto_awq_available
+from peft.tuners.lora.layer import LoraLayer
+from peft.tuners.tuners_utils import BaseTunerLayer
+if is_auto_awq_available():
+    from awq.modules.linear import WQLinear_GEMM
+
+class AwqLoraLinear(torch.nn.Module, LoraLayer):
+
+    def __init__(self, base_layer, adapter_name, r: int=0, lora_alpha: int=1, lora_dropout: float=0.0, init_lora_weights: bool=True, use_rslora: bool=False, **kwargs):
+        super().__init__()
+        LoraLayer.__init__(self, base_layer)
+        self.quant_linear_module = base_layer
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, lora_alpha, lora_dropout, init_lora_weights, use_rslora)
+
+    def forward(self, x: 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]
+            dropout = self.lora_dropout[active_adapter]
+            scaling = self.scaling[active_adapter]
+            requires_conversion = not torch.is_autocast_enabled()
+            if requires_conversion:
+                expected_dtype = result.dtype
+                x = x.to(lora_A.weight.dtype)
+            output = lora_B(lora_A(dropout(x)))
+            if requires_conversion:
+                output = output.to(expected_dtype)
+            output = output * scaling
+            result = result + output
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return 'lora.' + rep
+
+def dispatch_awq(target: torch.nn.Module, adapter_name: str, **kwargs: Any) -> Optional[torch.nn.Module]:
+    new_module = None
+    if isinstance(target, BaseTunerLayer):
+        target_base_layer = target.get_base_layer()
+    else:
+        target_base_layer = target
+    if is_auto_awq_available() and isinstance(target_base_layer, WQLinear_GEMM):
+        AUTOAWQ_MINIMUM_VERSION = packaging.version.parse('0.2.0')
+        version_autoawq = packaging.version.parse(importlib_metadata.version('autoawq'))
+        if AUTOAWQ_MINIMUM_VERSION > version_autoawq:
+            raise ImportError(f'Found an incompatible version of auto-awq. Found version {version_autoawq}, but only versions above {AUTOAWQ_MINIMUM_VERSION} are supported for PEFT.')
+        new_module = AwqLoraLinear(target, adapter_name, **kwargs)
+        target.qweight = target_base_layer.qweight
+    return new_module
+
+# File: peft-main/src/peft/tuners/lora/bnb.py
+from __future__ import annotations
+import warnings
+from typing import Any, Optional
+import bitsandbytes as bnb
+import torch
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+from peft.utils.integrations import dequantize_bnb_weight
+from peft.utils.other import transpose
+from .layer import LoraLayer
+if is_bnb_available():
+
+    class Linear8bitLt(torch.nn.Module, LoraLayer):
+
+        def __init__(self, base_layer: torch.nn.Module, adapter_name: str, r: int=0, lora_alpha: int=1, lora_dropout: float=0.0, init_lora_weights: bool=True, use_rslora: bool=False, use_dora: bool=False, **kwargs) -> None:
+            super().__init__()
+            LoraLayer.__init__(self, base_layer)
+            self.fan_in_fan_out = False
+            self._active_adapter = adapter_name
+            self.update_layer(adapter_name, r, lora_alpha=lora_alpha, lora_dropout=lora_dropout, init_lora_weights=init_lora_weights, use_rslora=use_rslora, use_dora=use_dora)
+
+        def merge(self, safe_merge: bool=False, adapter_names: Optional[list[str]]=None) -> None:
+            adapter_names = check_adapters_to_merge(self, adapter_names)
+            if not adapter_names:
+                return
+            for active_adapter in adapter_names:
+                if active_adapter not in self.lora_A.keys():
+                    continue
+                warnings.warn('Merge lora module to 8-bit linear may get different generations due to rounding errors.')
+                lora_data = self.get_delta_weight(active_adapter)
+                weight = self.get_base_layer().weight
+                state = self.get_base_layer().state
+                if state.SCB is None:
+                    state.SCB = weight.SCB
+                output = dequantize_bnb_weight(weight, state=state)
+                if not self.use_dora[active_adapter]:
+                    w_data = output.to(lora_data.dtype).to(lora_data.device) + lora_data
+                else:
+                    weight_norm = self.lora_magnitude_vector[active_adapter].get_weight_norm(output, lora_data, scaling=1).detach()
+                    self._cache_store(f'{active_adapter}-weight_norm', weight_norm)
+                    dora_factor = self.lora_magnitude_vector[active_adapter].weight / weight_norm
+                    w_data = dora_factor.view(-1, 1) * (output + lora_data)
+                if safe_merge and (not torch.isfinite(w_data).all()):
+                    raise ValueError(f'NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken')
+                self.get_base_layer().weight = bnb.nn.Int8Params(w_data.to('cpu'), requires_grad=False, has_fp16_weights=weight.has_fp16_weights).to(weight.device)
+                state.reset_grads()
+                self.merged_adapters.append(active_adapter)
+
+        def unmerge(self) -> None:
+            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 not in self.lora_A.keys():
+                    continue
+                warnings.warn('Unmerge lora module to 8-bit linear may get different generations due to rounding errors.')
+                lora_data = self.get_delta_weight(active_adapter)
+                weight = self.get_base_layer().weight
+                state = self.get_base_layer().state
+                if state.SCB is None:
+                    state.SCB = weight.SCB
+                output = dequantize_bnb_weight(weight, state=state)
+                if not self.use_dora[active_adapter]:
+                    w_data = output.to(lora_data.dtype).to(lora_data.device) - lora_data
+                else:
+                    weight_norm = self._cache_pop(f'{active_adapter}-weight_norm')
+                    dora_factor = self.lora_magnitude_vector[active_adapter].weight / weight_norm
+                    w_data = output.data / dora_factor.view(-1, 1) - lora_data
+                self.get_base_layer().weight = bnb.nn.Int8Params(w_data.to('cpu'), requires_grad=False, has_fp16_weights=weight.has_fp16_weights).to(weight.device)
+                state.reset_grads()
+
+        def get_delta_weight(self, adapter):
+            return transpose(self.lora_B[adapter].weight @ self.lora_A[adapter].weight, False) * self.scaling[adapter]
+
+        def _mixed_batch_forward(self, x: torch.Tensor, *args: Any, adapter_names: list[str], **kwargs: Any) -> torch.Tensor:
+            result = self.base_layer(x, *args, **kwargs)
+            unique_adapters = set(adapter_names)
+            sub_batch_indices_list = []
+            for adapter in unique_adapters:
+                sub_batch_indices_list.append([index for (index, item) in enumerate(adapter_names) if item == adapter])
+            for (i, active_adapter) in enumerate(unique_adapters):
+                if active_adapter == '__base__':
+                    continue
+                if active_adapter not in self.lora_A.keys():
+                    continue
+                lora_A = self.lora_A[active_adapter]
+                lora_B = self.lora_B[active_adapter]
+                dropout = self.lora_dropout[active_adapter]
+                scaling = self.scaling[active_adapter]
+                requires_conversion = not torch.is_autocast_enabled()
+                if requires_conversion:
+                    expected_dtype = result.dtype
+                    compute_dtype = lora_A.weight.dtype
+                    if x.dtype != compute_dtype:
+                        x = x.to(compute_dtype)
+                sub_batch = x[sub_batch_indices_list[i]]
+                output = lora_B(lora_A(dropout(sub_batch))) * scaling
+                if requires_conversion:
+                    output = output.to(expected_dtype)
+                result[sub_batch_indices_list[i]] += output
+            return result
+
+        def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+            self._check_forward_args(x, *args, **kwargs)
+            adapter_names = kwargs.pop('adapter_names', None)
+            if self.disable_adapters:
+                if self.merged:
+                    self.unmerge()
+                result = self.base_layer(x, *args, **kwargs)
+            elif adapter_names is not None:
+                result = self._mixed_batch_forward(x, *args, adapter_names=adapter_names, **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]
+                    dropout = self.lora_dropout[active_adapter]
+                    scaling = self.scaling[active_adapter]
+                    requires_conversion = not torch.is_autocast_enabled()
+                    if requires_conversion:
+                        expected_dtype = result.dtype
+                        compute_dtype = lora_A.weight.dtype
+                        if x.dtype != compute_dtype:
+                            x = x.to(compute_dtype)
+                    if not self.use_dora[active_adapter]:
+                        output = lora_B(lora_A(dropout(x))) * scaling
+                    else:
+                        x = dropout(x)
+                        output = self.lora_magnitude_vector[active_adapter](x, lora_A=lora_A, lora_B=lora_B, scaling=scaling, base_layer=self.get_base_layer())
+                    if requires_conversion:
+                        output = output.to(expected_dtype)
+                    result = result + output
+            return result
+
+        def __repr__(self) -> str:
+            rep = super().__repr__()
+            return 'lora.' + rep
+
+    def dispatch_bnb_8bit(target: torch.nn.Module, adapter_name: str, **kwargs):
+        new_module = None
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+        loaded_in_8bit = kwargs.get('loaded_in_8bit', False)
+        if loaded_in_8bit and isinstance(target_base_layer, bnb.nn.Linear8bitLt):
+            eightbit_kwargs = kwargs.copy()
+            eightbit_kwargs.update({'has_fp16_weights': target.state.has_fp16_weights, 'memory_efficient_backward': target.state.memory_efficient_backward, 'threshold': target.state.threshold, 'index': target.index})
+            new_module = Linear8bitLt(target, adapter_name, **eightbit_kwargs)
+        return new_module
+if is_bnb_4bit_available():
+
+    class Linear4bit(torch.nn.Module, LoraLayer):
+
+        def __init__(self, base_layer: torch.nn.Module, adapter_name: str, r: int=0, lora_alpha: int=1, lora_dropout: float=0.0, init_lora_weights: bool=True, use_rslora: bool=False, use_dora: bool=False, **kwargs) -> None:
+            super().__init__()
+            LoraLayer.__init__(self, base_layer)
+            self.fan_in_fan_out = False
+            self._active_adapter = adapter_name
+            self.update_layer(adapter_name, r, lora_alpha=lora_alpha, lora_dropout=lora_dropout, init_lora_weights=init_lora_weights, use_rslora=use_rslora, use_dora=use_dora)
+
+        def merge(self, safe_merge: bool=False, adapter_names: Optional[list[str]]=None) -> None:
+            adapter_names = check_adapters_to_merge(self, adapter_names)
+            if not adapter_names:
+                return
+            for active_adapter in adapter_names:
+                if active_adapter not in self.lora_A.keys():
+                    continue
+                warnings.warn('Merge lora module to 4-bit linear may get different generations due to rounding errors.')
+                weight = self.get_base_layer().weight
+                kwargs = weight.__dict__
+                lora_data = self.get_delta_weight(active_adapter)
+                output = dequantize_bnb_weight(weight, state=weight.quant_state)
+                if not self.use_dora[active_adapter]:
+                    w_data = output + lora_data
+                else:
+                    weight_norm = self.lora_magnitude_vector[active_adapter].get_weight_norm(output, lora_data, scaling=1).detach()
+                    self._cache_store(f'{active_adapter}-weight_norm', weight_norm)
+                    dora_factor = self.lora_magnitude_vector[active_adapter].weight / weight_norm
+                    w_data = dora_factor.view(-1, 1) * (output + lora_data)
+                if safe_merge and (not torch.isfinite(w_data).all()):
+                    raise ValueError(f'NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken')
+                if 'bnb_quantized' in kwargs:
+                    kwargs['bnb_quantized'] = False
+                kwargs['requires_grad'] = False
+                kwargs.pop('data', None)
+                self.get_base_layer().weight = bnb.nn.Params4bit(w_data.to('cpu'), **kwargs).to(weight.device)
+                self.merged_adapters.append(active_adapter)
+
+        def unmerge(self) -> None:
+            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 not in self.lora_A.keys():
+                    continue
+                warnings.warn('Unmerge lora module to 4-bit linear may get different generations due to rounding errors.')
+                lora_data = self.get_delta_weight(active_adapter)
+                weight = self.get_base_layer().weight
+                kwargs = weight.__dict__
+                output = dequantize_bnb_weight(weight, state=weight.quant_state)
+                if not self.use_dora[active_adapter]:
+                    w_data = output - lora_data
+                else:
+                    weight_norm = self._cache_pop(f'{active_adapter}-weight_norm')
+                    dora_factor = self.lora_magnitude_vector[active_adapter].weight / weight_norm
+                    w_data = output.data / dora_factor.view(-1, 1) - lora_data
+                if 'bnb_quantized' in kwargs:
+                    kwargs['bnb_quantized'] = False
+                kwargs['requires_grad'] = False
+                kwargs.pop('data', None)
+                self.get_base_layer().weight = bnb.nn.Params4bit(w_data.to('cpu'), **kwargs).to(weight.device)
+
+        def get_delta_weight(self, adapter):
+            return transpose(self.lora_B[adapter].weight @ self.lora_A[adapter].weight, False) * self.scaling[adapter]
+
+        def _mixed_batch_forward(self, x: torch.Tensor, *args: Any, adapter_names: list[str], **kwargs: Any) -> torch.Tensor:
+            result = self.base_layer(x, *args, **kwargs)
+            unique_adapters = set(adapter_names)
+            sub_batch_indices_list = []
+            for adapter in unique_adapters:
+                sub_batch_indices_list.append([index for (index, item) in enumerate(adapter_names) if item == adapter])
+            for (i, active_adapter) in enumerate(unique_adapters):
+                if active_adapter == '__base__':
+                    continue
+                if active_adapter not in self.lora_A.keys():
+                    continue
+                lora_A = self.lora_A[active_adapter]
+                lora_B = self.lora_B[active_adapter]
+                dropout = self.lora_dropout[active_adapter]
+                scaling = self.scaling[active_adapter]
+                requires_conversion = not torch.is_autocast_enabled()
+                if requires_conversion:
+                    expected_dtype = result.dtype
+                    x = x.to(lora_A.weight.dtype)
+                sub_batch = x[sub_batch_indices_list[i]]
+                output = lora_B(lora_A(dropout(sub_batch))) * scaling
+                if requires_conversion:
+                    output = output.to(expected_dtype)
+                result[sub_batch_indices_list[i]] += output
+            return result
+
+        def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+            self._check_forward_args(x, *args, **kwargs)
+            adapter_names = kwargs.pop('adapter_names', None)
+            if self.disable_adapters:
+                if self.merged:
+                    self.unmerge()
+                result = self.base_layer(x, *args, **kwargs)
+            elif adapter_names is not None:
+                result = self._mixed_batch_forward(x, *args, adapter_names=adapter_names, **kwargs)
+            elif self.merged:
+                result = self.base_layer(x, *args, **kwargs)
+            else:
+                result = self.base_layer(x, *args, **kwargs)
+                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]
+                    dropout = self.lora_dropout[active_adapter]
+                    scaling = self.scaling[active_adapter]
+                    requires_conversion = not torch.is_autocast_enabled()
+                    if requires_conversion:
+                        expected_dtype = result.dtype
+                        x = x.to(lora_A.weight.dtype)
+                    if not self.use_dora[active_adapter]:
+                        output = lora_B(lora_A(dropout(x))) * scaling
+                    else:
+                        x = dropout(x)
+                        output = self.lora_magnitude_vector[active_adapter](x, lora_A=lora_A, lora_B=lora_B, scaling=scaling, base_layer=self.get_base_layer())
+                    if requires_conversion:
+                        output = output.to(expected_dtype)
+                    result = result + output
+            return result
+
+        def __repr__(self) -> str:
+            rep = super().__repr__()
+            return 'lora.' + rep
+
+    def dispatch_bnb_4bit(target: torch.nn.Module, adapter_name: str, **kwargs):
+        new_module = None
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+        loaded_in_4bit = kwargs.get('loaded_in_4bit', False)
+        if 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 = Linear4bit(target, adapter_name, **fourbit_kwargs)
+        return new_module
+
+# File: peft-main/src/peft/tuners/lora/config.py
+from __future__ import annotations
+import warnings
+from dataclasses import dataclass, field
+from typing import Literal, Optional, Union
+from torch import nn
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+@dataclass
+class LoraRuntimeConfig:
+    ephemeral_gpu_offload: bool = field(default=False, metadata={'help': 'Whether to use ephemeral GPU offloading for models partially kept in CPU memory. Ephemeral GPU offloading result in the data involved in intense operations being momentarily copied over to the GPU, and the results copied back to CPU. There is a momentary VRAM overhead, but operations are generally orders of magnitude faster compared to performing them on the CPU. This is useful when parts of the model and/or components (such as adapters) are kept in CPU memory until they are needed. Rather than perform expensive operations on small data, the data is transferred to the GPU on-demand, the operation(s) performed, and the results moved back to CPU memory. Currently only affects DoRA initialization.'})
+
+@dataclass
+class LoftQConfig:
+    loftq_bits: int = field(default=4, metadata={'help': 'Quantization bits for LoftQ'})
+    loftq_iter: int = field(default=1, metadata={'help': 'Alternating iterations for LoftQ'})
+
+@dataclass
+class LoraConfig(PeftConfig):
+    r: int = field(default=8, metadata={'help': 'Lora attention dimension'})
+    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 LoRA.For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'.This can also be a wildcard 'all-linear' which matches all linear/Conv1D layers except the output layer.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."})
+    lora_alpha: int = field(default=8, metadata={'help': 'Lora alpha'})
+    lora_dropout: float = field(default=0.0, metadata={'help': 'Lora dropout'})
+    fan_in_fan_out: bool = field(default=False, metadata={'help': 'Set this to True if the layer to replace stores weight like (fan_in, fan_out)'})
+    bias: Literal['none', 'all', 'lora_only'] = field(default='none', metadata={'help': "Bias type for Lora. Can be 'none', 'all' or 'lora_only'"})
+    use_rslora: bool = field(default=False, metadata={'help': "When set to True, uses <a href='https://doi.org/10.48550/arXiv.2312.03732'>Rank-Stabilized LoRA</a> which sets the adapter scaling factor to `lora_alpha/math.sqrt(r)`, since it was proven to work better. Otherwise, it will use the original default value of `lora_alpha/r`."})
+    modules_to_save: Optional[list[str]] = field(default=None, metadata={'help': 'List of modules apart from LoRA 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_lora_weights: bool | Literal['gaussian', 'olora', 'pissa', 'pissa_niter_[number of iters]', 'loftq'] = field(default=True, metadata={'help': "How to initialize the weights of the LoRA layers. Passing `'True'` (default) results in the default initialization from the reference implementation from Microsoft. Passing `'gaussian'` results in Gaussian initialization scaled by the LoRA rank for linear and layers. Setting the initialization to `'False'` leads to completely random initialization and *is discouraged.*Passing `'olora'` results in OLoRA initialization.Passing `'pissa'` results in PiSSA initialization.Passing `'pissa_niter_[number of iters]'` initiates Fast-SVD-based PiSSA initialization, where [number of iters] indicates the number of subspace iterations to perform fsvd, and must be a nonnegative integer.Pass `'loftq'` to use LoftQ initialization"})
+    layers_to_transform: Optional[Union[list[int], int]] = field(default=None, metadata={'help': 'The layer indexes to transform, is this argument is specified, PEFT will transform only the layers indexes that are specified inside this list. If a single integer is passed, PEFT will transform only the layer at this index. This only works when target_modules is a list of str.'})
+    layers_pattern: Optional[Union[list[str], str]] = field(default=None, metadata={'help': 'The layer pattern name, used only if `layers_to_transform` is different to None and if the layer pattern is not in the common layers pattern.This only works when target_modules is a list of str.'})
+    rank_pattern: Optional[dict] = field(default_factory=dict, metadata={'help': 'The mapping from layer names or regexp expression to ranks which are different from the default rank specified by `r`. For example, `{model.decoder.layers.0.encoder_attn.k_proj: 8`}'})
+    alpha_pattern: Optional[dict] = field(default_factory=dict, metadata={'help': 'The mapping from layer names or regexp expression to alphas which are different from the default alpha specified by `lora_alpha`. For example, `{model.decoder.layers.0.encoder_attn.k_proj: 32`}'})
+    megatron_config: Optional[dict] = field(default=None, metadata={'help': "The TransformerConfig from Megatron. It is used to create LoRA's parallel linear layer.You can get it like this, `core_transformer_config_from_args(get_args())`, these two functions being from Megatron.You need to specify this parameter when you want to apply LoRA to the ColumnParallelLinear and RowParallelLinear layers of megatron.It should be noted that we may not be able to use the `save_pretrained` and `from_pretrained` functions, because TransformerConfig may not necessarily be serialized.But when using megatron, we can use `get_peft_model_state_dict` function and megatron's framework, they can also save and load models and configurations."})
+    megatron_core: Optional[str] = field(default='megatron.core', metadata={'help': "The core module from Megatron, it is used to create LoRA's parallel linear layer. It only needs to be passed in when you need to use your own modified megatron core module. Otherwise, it will use the default value `megatron.core`. "})
+    loftq_config: Union[LoftQConfig, dict] = field(default_factory=dict, metadata={'help': "The configuration of LoftQ. If this is passed, then LoftQ will be used to quantize the backbone weights and initialize Lora layers. Also set `init_lora_weights='loftq'` in this case."})
+    use_dora: bool = field(default=False, metadata={'help': "Enable <a href='https://arxiv.org/abs/2402.09353'>'Weight-Decomposed Low-Rank Adaptation' (DoRA)</a>. This technique decomposes the updates of the weights into two parts, magnitude and direction. Direction is handled by normal LoRA, whereas the magnitude is handled by a separate learnable parameter. This can improve the performance of LoRA, especially at low ranks. Right now, DoRA only supports linear and Conv2D layers. DoRA introduces a biggeroverhead than pure LoRA, so it is recommended to merge weights for inference."})
+    layer_replication: Optional[list[tuple[int, int]]] = field(default=None, metadata={'help': 'This enables using LoRA to effectively expand a transformer model to a larger size by repeating some layers. The transformation handles models (currently Llama, Bert or Falcon compatible architectures) with a module list in the model which it modifies to expand the number of modules. Base weights are shared so the memory usage is close to the original model. The intended use is these base weights remain fixed during finetuning but each layer has a separate LoRA adapter so the layers can be specialed via the adapter layers fit during fine tuning.The format is a list of [start, end) pairs which specify the layer ranges to stack. For example:\n   Original model has 5 layers labelled by their position in the model: `[0, 1, 2, 3, 4]`\n   layer_replication: `[[0, 4], [2, 5]]`\n   Final model will have this arrangement of original layers: `[0, 1, 2, 3, 2, 3, 4]`\nThis format is based on what is used for pass-through merges in mergekit. It makes it simple to select sequential ranges of a model and stack them while reusing layers at either end of each sequence.'})
+    runtime_config: LoraRuntimeConfig = field(default_factory=LoraRuntimeConfig, metadata={'help': 'Runtime configurations'})
+
+    def to_dict(self):
+        rv = super().to_dict()
+        rv.pop('runtime_config')
+        return rv
+
+    def __post_init__(self):
+        self.peft_type = PeftType.LORA
+        self.target_modules = set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        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.')
+        if isinstance(self.target_modules, str) and self.layers_pattern is not None:
+            raise ValueError('`layers_pattern` cannot be used when `target_modules` is a str.')
+        if self.use_dora and self.megatron_config:
+            raise ValueError('DoRA does not support megatron_core, please set `use_dora=False`.')
+        if self.init_lora_weights == 'loftq':
+            import importlib
+            if not importlib.util.find_spec('scipy'):
+                raise ImportError("The required package 'scipy' is not installed. Please install it to continue.")
+            if self.loftq_config is None:
+                raise ValueError("`loftq_config` must be specified when `init_lora_weights` is 'loftq'.")
+        if self.use_rslora and (self.rank_pattern or self.alpha_pattern) and (isinstance(self.init_lora_weights, str) and self.init_lora_weights.startswith('pissa') or self.init_lora_weights == 'olora'):
+            msg = "Using Rank-Stabilized LoRA with rank_pattern/alpha_pattern and post-training conversion of modified base weights (PiSSA, OLoRA) means that you won't be able to pass `path_initial_model_for_weight_conversion` to `save_pretrained` to restore the initial values of the base weights; if you intend to do this, please ensure not to use rslora or rank_pattern/alpha_pattern."
+            warnings.warn(msg)
+        if self.loftq_config and (not isinstance(self.loftq_config, dict)):
+            self.loftq_config = vars(self.loftq_config)
+        self._custom_modules: Optional[dict[type[nn.Mmodule], type[nn.Module]]] = None
+
+    def _register_custom_module(self, mapping: dict[type[nn.Mmodule], type[nn.Module]]) -> None:
+        if self._custom_modules is None:
+            self._custom_modules = {}
+        self._custom_modules.update(mapping)
+
+# File: peft-main/src/peft/tuners/lora/dora.py
+from copy import deepcopy
+import torch
+import torch.nn.functional as F
+from torch import nn
+from peft.utils.integrations import dequantize_module_weight, gather_params_ctx
+from peft.utils.other import transpose
+
+class DoraLinearLayer(nn.Module):
+
+    def __init__(self, fan_in_fan_out):
+        super().__init__()
+        self.fan_in_fan_out = fan_in_fan_out
+
+    def get_weight_norm(self, weight, lora_weight, scaling) -> torch.Tensor:
+        weight = transpose(weight, self.fan_in_fan_out)
+        weight = weight + scaling * lora_weight
+        weight_norm = torch.linalg.norm(weight, dim=1).to(weight.dtype)
+        return weight_norm
+
+    def update_layer(self, *, base_layer, lora_A, lora_B, scaling, place_on_cpu=False) -> None:
+        dtype_is_fp16 = lora_A.dtype == torch.float16
+        if dtype_is_fp16:
+            lora_A = lora_A.float()
+            lora_B = lora_B.float()
+        with gather_params_ctx(base_layer.parameters()):
+            if base_layer.__class__.__name__ == 'Linear4bit':
+                base_layer = deepcopy(base_layer)
+            weight = dequantize_module_weight(base_layer)
+            if weight.data.ndim == 4:
+                lora_weight = torch.mm(lora_B.flatten(start_dim=1), lora_A.flatten(start_dim=1))
+                lora_weight = lora_weight.reshape(weight.shape)
+            else:
+                lora_weight = lora_B @ lora_A
+            if dtype_is_fp16:
+                lora_weight = lora_weight.half()
+            weight_norm = self.get_weight_norm(weight.to(lora_A.device), lora_weight, scaling)
+        if place_on_cpu:
+            weight_norm = weight_norm.to('cpu')
+        self.weight = nn.Parameter(weight_norm, requires_grad=True)
+
+    def forward(self, x, *, lora_A, lora_B, scaling, base_layer):
+        lora_result = lora_B(lora_A(x))
+        x_eye = torch.eye(lora_A.weight.shape[1], device=lora_A.weight.device, dtype=x.dtype)
+        lora_weight = lora_B(lora_A(x_eye)).T
+        magnitude = self.weight
+        weight = dequantize_module_weight(base_layer)
+        weight = weight.to(x.dtype)
+        weight_norm = self.get_weight_norm(weight, lora_weight.detach(), scaling)
+        weight_norm = weight_norm.detach()
+        mag_norm_scale = (magnitude / weight_norm).view(1, -1)
+        result_dora = (mag_norm_scale - 1) * F.linear(x, transpose(weight, self.fan_in_fan_out)) + mag_norm_scale * lora_result * scaling
+        return result_dora
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return 'lora.dora.' + rep
+
+class DoraEmbeddingLayer(DoraLinearLayer):
+
+    def forward(self, x, *, lora_A, lora_B, scaling, base_layer, embed_fn):
+        lora_weight = (lora_A @ lora_B).T
+        magnitude = self.weight
+        weight = base_layer.weight
+        weight_norm = self.get_weight_norm(weight, lora_weight.detach(), scaling)
+        weight_norm = weight_norm.detach()
+        mag_norm_scale = magnitude / weight_norm
+        result_dora = mag_norm_scale * (embed_fn(x, lora_A) @ lora_B) * scaling
+        return (mag_norm_scale, result_dora)
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return 'lora.dora.' + rep
+
+class DoraConv2dLayer(DoraLinearLayer):
+
+    def get_weight_norm(self, weight, lora_weight, scaling) -> torch.Tensor:
+        weight = weight + scaling * lora_weight
+        weight_norm = weight.norm(p=2, dim=(1, 2, 3), keepdim=True).transpose(1, 0)
+        return weight_norm
+
+    def forward(self, x, *, lora_A, lora_B, scaling, base_layer):
+        weight = base_layer.weight
+        lora_weight = torch.mm(lora_B.weight.flatten(start_dim=1), lora_A.weight.flatten(start_dim=1))
+        lora_weight = lora_weight.reshape(weight.shape)
+        magnitude = self.weight
+        weight_norm = self.get_weight_norm(weight, lora_weight.detach(), scaling)
+        weight_norm = weight_norm.detach()
+        mag_norm_scale = magnitude / weight_norm
+        result_dora = (mag_norm_scale - 1) * F.conv2d(x, weight, bias=None, stride=base_layer.stride, padding=base_layer.padding, dilation=base_layer.dilation, groups=base_layer.groups) + mag_norm_scale * lora_B(lora_A(x)) * scaling
+        return result_dora
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return 'lora.dora.' + rep
+
+# File: peft-main/src/peft/tuners/lora/eetq.py
+from typing import Any, List, Optional
+import torch
+from peft.import_utils import is_eetq_available
+from peft.tuners.lora.layer import LoraLayer
+from peft.tuners.tuners_utils import BaseTunerLayer
+if is_eetq_available():
+    from eetq import EetqLinear
+
+    class EetqLoraLinear(torch.nn.Module, LoraLayer):
+
+        def __init__(self, base_layer, adapter_name, r: int=0, lora_alpha: int=1, lora_dropout: float=0.0, init_lora_weights: bool=True, use_rslora: bool=False, **kwargs):
+            super().__init__()
+            LoraLayer.__init__(self, base_layer)
+            self.quant_linear_module = base_layer
+            self._active_adapter = adapter_name
+            self.update_layer(adapter_name, r, lora_alpha, lora_dropout, init_lora_weights, use_rslora)
+
+        def forward(self, x: 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]
+                dropout = self.lora_dropout[active_adapter]
+                scaling = self.scaling[active_adapter]
+                requires_conversion = not torch.is_autocast_enabled()
+                if requires_conversion:
+                    expected_dtype = result.dtype
+                    x = x.to(lora_A.weight.dtype)
+                output = lora_B(lora_A(dropout(x)))
+                if requires_conversion:
+                    output = output.to(expected_dtype)
+                output = output * scaling
+                result = result + output
+            return result
+
+        def merge(self, safe_merge: bool=False, adapter_names: Optional[List[str]]=None) -> None:
+            raise AttributeError('Merging LoRA layers is not supported for Eetq layers.')
+
+        def unmerge(self) -> None:
+            raise AttributeError('Unmerging LoRA layers is not supported for Eetq layers.')
+
+        def __repr__(self) -> str:
+            rep = super().__repr__()
+            return 'lora.' + rep
+
+def dispatch_eetq(target: torch.nn.Module, adapter_name: str, **kwargs: Any) -> Optional[torch.nn.Module]:
+    new_module = None
+    if isinstance(target, BaseTunerLayer):
+        target_base_layer = target.get_base_layer()
+    else:
+        target_base_layer = target
+    if is_eetq_available() and isinstance(target_base_layer, EetqLinear):
+        new_module = EetqLoraLinear(target, adapter_name, **kwargs)
+        target.weight = target_base_layer.weight
+        if hasattr(target, 'bias'):
+            target.bias = target_base_layer.bias
+    return new_module
+
+# File: peft-main/src/peft/tuners/lora/gptq.py
+from typing import Any, Optional
+import torch
+from peft.tuners.lora.layer import LoraLayer
+from peft.tuners.tuners_utils import BaseTunerLayer
+from peft.utils import get_auto_gptq_quant_linear
+
+class QuantLinear(torch.nn.Module, LoraLayer):
+
+    def __init__(self, base_layer, adapter_name: str, r: int=0, lora_alpha: int=1, lora_dropout: float=0.0, init_lora_weights: bool=True, use_rslora: bool=False, use_dora: bool=False, **kwargs):
+        super().__init__()
+        LoraLayer.__init__(self, base_layer)
+        if use_dora:
+            raise ValueError(f'{self.__class__.__name__} does not support DoRA yet, please set it to False')
+        self.quant_linear_module = base_layer
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, lora_alpha=lora_alpha, lora_dropout=lora_dropout, init_lora_weights=init_lora_weights, use_rslora=use_rslora, use_dora=use_dora)
+
+    def forward(self, x: 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]
+            dropout = self.lora_dropout[active_adapter]
+            scaling = self.scaling[active_adapter]
+            requires_conversion = not torch.is_autocast_enabled()
+            if requires_conversion:
+                expected_dtype = result.dtype
+                x = x.to(lora_A.weight.dtype)
+            output = lora_B(lora_A(dropout(x)))
+            if requires_conversion:
+                output = output.to(expected_dtype)
+            output = output * scaling
+            result += output
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return 'lora.' + rep
+
+def dispatch_gptq(target: torch.nn.Module, adapter_name: str, **kwargs: Any) -> Optional[torch.nn.Module]:
+    new_module = None
+    if isinstance(target, BaseTunerLayer):
+        target_base_layer = target.get_base_layer()
+    else:
+        target_base_layer = target
+    gptq_quantization_config = kwargs.get('gptq_quantization_config', None)
+    AutoGPTQQuantLinear = get_auto_gptq_quant_linear(gptq_quantization_config)
+    if AutoGPTQQuantLinear is not None and isinstance(target_base_layer, AutoGPTQQuantLinear):
+        new_module = QuantLinear(target, adapter_name, **kwargs)
+        target.qweight = target_base_layer.qweight
+    return new_module
+
+# File: peft-main/src/peft/tuners/lora/hqq.py
+from __future__ import annotations
+import copy
+import warnings
+from typing import Any, Optional
+import torch
+from peft.import_utils import is_hqq_available
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+from peft.utils.other import transpose
+from .layer import LoraLayer
+if is_hqq_available():
+    from hqq.core.quantize import HQQLinear
+
+    class HqqLoraLinear(torch.nn.Module, LoraLayer):
+
+        def __init__(self, base_layer: torch.nn.Module, adapter_name: str, r: int=0, lora_alpha: int=1, lora_dropout: float=0.0, init_lora_weights: bool=True, use_rslora: bool=False, use_dora: bool=False, **kwargs) -> None:
+            super().__init__()
+            LoraLayer.__init__(self, base_layer)
+            self.fan_in_fan_out = False
+            self._active_adapter = adapter_name
+            self.update_layer(adapter_name, r, lora_alpha=lora_alpha, lora_dropout=lora_dropout, init_lora_weights=init_lora_weights, use_rslora=use_rslora, use_dora=use_dora)
+
+        def merge(self, safe_merge: bool=False, adapter_names: Optional[list[str]]=None) -> None:
+            adapter_names = check_adapters_to_merge(self, adapter_names)
+            if not adapter_names:
+                return
+            for active_adapter in adapter_names:
+                if active_adapter not in self.lora_A.keys():
+                    continue
+                layer = self.get_base_layer()
+                quant_config = {**copy.deepcopy(layer.quant_config), 'offload_meta': layer.offload_meta}
+                lora_data = self.get_delta_weight(active_adapter)
+                output = layer.dequantize()
+                if not self.use_dora[active_adapter]:
+                    w_data = output + lora_data
+                else:
+                    weight_norm = self._get_weight_norm(output, lora_data, scaling=1).detach()
+                    self._cache_store(f'{active_adapter}-weight_norm', weight_norm)
+                    dora_factor = self.lora_magnitude_vector[active_adapter] / weight_norm
+                    w_data = dora_factor.view(-1, 1) * (output + lora_data)
+                if safe_merge and (not torch.isfinite(w_data).all()):
+                    raise ValueError(f'NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken')
+                new_hqq_layer = HQQLinear(None, quant_config, compute_dtype=layer.compute_dtype, device=layer.device)
+                quant_config.pop('offload_meta', None)
+                new_hqq_layer.quantize(w_data, **quant_config)
+                self.base_layer = new_hqq_layer
+                self.merged_adapters.append(active_adapter)
+
+        def unmerge(self) -> None:
+            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 not in self.lora_A.keys():
+                    continue
+                lora_data = self.get_delta_weight(active_adapter)
+                layer = self.get_base_layer()
+                quant_config = {**copy.deepcopy(layer.quant_config), 'offload_meta': layer.offload_meta}
+                output = layer.dequantize()
+                if not self.use_dora[active_adapter]:
+                    w_data = output - lora_data
+                else:
+                    weight_norm = self._cache_pop(f'{active_adapter}-weight_norm')
+                    dora_factor = self.lora_magnitude_vector[active_adapter] / weight_norm
+                    w_data = output.data / dora_factor.view(-1, 1) - lora_data
+                new_hqq_layer = HQQLinear(None, quant_config, compute_dtype=layer.compute_dtype, device=layer.device)
+                quant_config.pop('offload_meta', None)
+                new_hqq_layer.quantize(w_data, **quant_config)
+                self.base_layer = new_hqq_layer
+
+        def get_delta_weight(self, adapter):
+            return transpose(self.lora_B[adapter].weight @ self.lora_A[adapter].weight, False) * self.scaling[adapter]
+
+        def _mixed_batch_forward(self, x: torch.Tensor, *args: Any, adapter_names: list[str], **kwargs: Any) -> torch.Tensor:
+            result = self.base_layer(x, *args, **kwargs)
+            unique_adapters = set(adapter_names)
+            sub_batch_indices_list = []
+            for adapter in unique_adapters:
+                sub_batch_indices_list.append([index for (index, item) in enumerate(adapter_names) if item == adapter])
+            for (i, active_adapter) in enumerate(unique_adapters):
+                if active_adapter == '__base__':
+                    continue
+                if active_adapter not in self.lora_A.keys():
+                    continue
+                lora_A = self.lora_A[active_adapter]
+                lora_B = self.lora_B[active_adapter]
+                dropout = self.lora_dropout[active_adapter]
+                scaling = self.scaling[active_adapter]
+                requires_conversion = not torch.is_autocast_enabled()
+                if requires_conversion:
+                    expected_dtype = result.dtype
+                    compute_dtype = lora_A.weight.dtype
+                    if x.dtype != compute_dtype:
+                        x = x.to(compute_dtype)
+                sub_batch = x[sub_batch_indices_list[i]]
+                output = lora_B(lora_A(dropout(sub_batch))) * scaling
+                if requires_conversion:
+                    output = output.to(expected_dtype)
+                result[sub_batch_indices_list[i]] += output
+            return result
+
+        def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+            self._check_forward_args(x, *args, **kwargs)
+            adapter_names = kwargs.pop('adapter_names', None)
+            if self.disable_adapters:
+                if self.merged:
+                    self.unmerge()
+                result = self.base_layer(x, *args, **kwargs)
+            elif adapter_names is not None:
+                result = self._mixed_batch_forward(x, *args, adapter_names=adapter_names, **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]
+                    dropout = self.lora_dropout[active_adapter]
+                    scaling = self.scaling[active_adapter]
+                    requires_conversion = not torch.is_autocast_enabled()
+                    if requires_conversion:
+                        expected_dtype = result.dtype
+                        compute_dtype = lora_A.weight.dtype
+                        if x.dtype != compute_dtype:
+                            x = x.to(compute_dtype)
+                    if not self.use_dora[active_adapter]:
+                        output = lora_B(lora_A(dropout(x))) * scaling
+                    else:
+                        output = self._apply_dora(x, lora_A, lora_B, scaling, active_adapter)
+                    if requires_conversion:
+                        output = output.to(expected_dtype)
+                    result = result + output
+            return result
+
+        def __repr__(self) -> str:
+            rep = super().__repr__()
+            return 'lora.' + rep
+
+def dispatch_hqq(target: torch.nn.Module, adapter_name: str, **kwargs):
+    new_module = None
+    if isinstance(target, BaseTunerLayer):
+        target_base_layer = target.get_base_layer()
+    else:
+        target_base_layer = target
+    if is_hqq_available() and isinstance(target_base_layer, HQQLinear):
+        new_module = HqqLoraLinear(target_base_layer, adapter_name, **kwargs)
+    return new_module
+
+# File: peft-main/src/peft/tuners/lora/layer.py
+from __future__ import annotations
+import math
+import warnings
+from typing import Any, Optional, Union
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from accelerate.utils.imports import is_xpu_available
+from torch import svd_lowrank
+from transformers.pytorch_utils import Conv1D
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+from peft.utils.integrations import dequantize_module_weight, gather_params_ctx, get_bnb_param_type
+from peft.utils.other import transpose
+from .config import LoraConfig
+from .dora import DoraConv2dLayer, DoraEmbeddingLayer, DoraLinearLayer
+
+class LoraLayer(BaseTunerLayer):
+    adapter_layer_names = ('lora_A', 'lora_B', 'lora_embedding_A', 'lora_embedding_B')
+    other_param_names = ('r', 'lora_alpha', 'scaling', 'lora_dropout')
+
+    def __init__(self, base_layer: nn.Module, ephemeral_gpu_offload: bool=False, **kwargs) -> None:
+        self.base_layer = base_layer
+        self.r = {}
+        self.lora_alpha = {}
+        self.scaling = {}
+        self.lora_dropout = nn.ModuleDict({})
+        self.lora_A = nn.ModuleDict({})
+        self.lora_B = nn.ModuleDict({})
+        self.lora_embedding_A = nn.ParameterDict({})
+        self.lora_embedding_B = nn.ParameterDict({})
+        self._disable_adapters = False
+        self.merged_adapters = []
+        self.use_dora: dict[str, bool] = {}
+        self.lora_magnitude_vector = torch.nn.ModuleDict()
+        self._caches: dict[str, Any] = {}
+        self.ephemeral_gpu_offload: bool = ephemeral_gpu_offload
+        self.kwargs = kwargs
+        base_layer = self.get_base_layer()
+        if isinstance(base_layer, nn.Linear):
+            (in_features, out_features) = (base_layer.in_features, base_layer.out_features)
+        elif isinstance(base_layer, nn.Conv2d):
+            (in_features, out_features) = (base_layer.in_channels, base_layer.out_channels)
+        elif isinstance(base_layer, nn.Embedding):
+            (in_features, out_features) = (base_layer.num_embeddings, base_layer.embedding_dim)
+        elif isinstance(base_layer, Conv1D):
+            (in_features, out_features) = base_layer.weight.ds_shape if hasattr(base_layer.weight, 'ds_shape') else base_layer.weight.shape
+        elif hasattr(base_layer, 'infeatures') and hasattr(base_layer, 'outfeatures'):
+            (in_features, out_features) = (base_layer.infeatures, base_layer.outfeatures)
+        elif hasattr(base_layer, 'input_size') and hasattr(base_layer, 'output_size'):
+            (in_features, out_features) = (base_layer.input_size, base_layer.output_size)
+        elif hasattr(base_layer, 'codebooks') and base_layer.__class__.__name__ == 'QuantizedLinear':
+            (in_features, out_features) = (base_layer.in_features, base_layer.out_features)
+        elif hasattr(base_layer, 'w_bit') and base_layer.__class__.__name__ == 'WQLinear_GEMM':
+            (in_features, out_features) = (base_layer.in_features, base_layer.out_features)
+        elif base_layer.__class__.__name__ == 'EetqLinear':
+            (in_features, out_features) = (base_layer.in_features, base_layer.out_features)
+        elif hasattr(base_layer, 'W_q') and base_layer.__class__.__name__ == 'HQQLinear':
+            (in_features, out_features) = (base_layer.in_features, base_layer.out_features)
+        else:
+            if hasattr(base_layer, 'in_features') and hasattr(base_layer, 'out_features'):
+                (in_features, out_features) = (base_layer.in_features, base_layer.out_features)
+            else:
+                (in_features, out_features) = (None, None)
+            warnings.warn(f"Unsupported layer type '{type(base_layer)}' encountered, proceed at your own risk.", UserWarning)
+        self.in_features = in_features
+        self.out_features = out_features
+
+    def update_layer(self, adapter_name, r, lora_alpha, lora_dropout, init_lora_weights, use_rslora, use_dora: bool=False):
+        if r <= 0:
+            raise ValueError(f'`r` should be a positive integer value 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.update(nn.ModuleDict({adapter_name: lora_dropout_layer}))
+        self.lora_A[adapter_name] = nn.Linear(self.in_features, r, bias=False)
+        self.lora_B[adapter_name] = nn.Linear(r, self.out_features, bias=False)
+        if use_rslora:
+            self.scaling[adapter_name] = lora_alpha / math.sqrt(r)
+        else:
+            self.scaling[adapter_name] = lora_alpha / r
+        if isinstance(init_lora_weights, str) and init_lora_weights.startswith('pissa'):
+            with gather_params_ctx(self.get_base_layer().weight):
+                self.pissa_init(adapter_name, init_lora_weights)
+        elif isinstance(init_lora_weights, str) and init_lora_weights.lower() == 'olora':
+            with gather_params_ctx(self.get_base_layer().weight):
+                self.olora_init(adapter_name)
+        elif init_lora_weights == 'loftq':
+            with gather_params_ctx(self.get_base_layer().weight):
+                self.loftq_init(adapter_name)
+        elif init_lora_weights:
+            self.reset_lora_parameters(adapter_name, init_lora_weights)
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        if use_dora:
+            self.dora_init(adapter_name)
+            self.use_dora[adapter_name] = True
+        else:
+            self.use_dora[adapter_name] = False
+        self.set_adapter(self.active_adapters)
+
+    def reset_lora_parameters(self, adapter_name, init_lora_weights):
+        if init_lora_weights is False:
+            return
+        if adapter_name in self.lora_A.keys():
+            if init_lora_weights is True:
+                nn.init.kaiming_uniform_(self.lora_A[adapter_name].weight, a=math.sqrt(5))
+            elif init_lora_weights.lower() == 'gaussian':
+                nn.init.normal_(self.lora_A[adapter_name].weight, std=1 / self.r[adapter_name])
+            else:
+                raise ValueError(f'Unknown initialization init_lora_weights={init_lora_weights!r}')
+            nn.init.zeros_(self.lora_B[adapter_name].weight)
+        if adapter_name in self.lora_embedding_A.keys():
+            nn.init.zeros_(self.lora_embedding_A[adapter_name])
+            nn.init.normal_(self.lora_embedding_B[adapter_name])
+
+    def olora_init(self, adapter_name):
+        base_layer = self.get_base_layer()
+        orig_weight = base_layer.weight
+        bnb_param_type = get_bnb_param_type(orig_weight)
+        dtype = orig_weight.dtype
+        if bnb_param_type:
+            weight_tensor = dequantize_module_weight(base_layer)
+        elif dtype in [torch.float32, torch.float16, torch.bfloat16]:
+            weight_tensor = orig_weight
+        else:
+            raise TypeError(f'Unsupported data type for the base layer. Got {dtype}.')
+        scale_factor = self.scaling[adapter_name]
+        r = self.r[adapter_name]
+        weight_tensor = weight_tensor.to(torch.float32)
+        (Q, R) = torch.linalg.qr(weight_tensor.data)
+        (Qr, Rr) = (Q[:, :r], R[:r])
+        self.lora_A[adapter_name].weight.data = Rr.contiguous()
+        self.lora_B[adapter_name].weight.data = Qr.contiguous()
+        weight_tensor.data -= scale_factor * self.lora_B[adapter_name].weight @ self.lora_A[adapter_name].weight
+        if bnb_param_type == '4bit':
+            weight_tensor = orig_weight.__class__(weight_tensor, quant_type=orig_weight.quant_type, quant_storage=orig_weight.quant_storage, compress_statistics=orig_weight.compress_statistics, module=orig_weight.module).to(orig_weight.device)
+            base_layer.weight = weight_tensor
+        elif bnb_param_type == '8bit':
+            weight_tensor = orig_weight.__class__(weight_tensor, requires_grad=orig_weight.requires_grad, has_fp16_weights=orig_weight.has_fp16_weights).to(orig_weight.device)
+            base_layer.weight = weight_tensor
+        else:
+            weight_tensor = weight_tensor.to(dtype)
+            base_layer.weight.data = weight_tensor
+
+    def pissa_init(self, adapter_name, init_lora_weights):
+        weight = self.get_base_layer().weight
+        dtype = weight.dtype
+        if dtype not in [torch.float32, torch.float16, torch.bfloat16]:
+            raise TypeError('Please initialize PiSSA under float32, float16, or bfloat16. Subsequently, re-quantize the residual model to help minimize quantization errors.')
+        weight = weight.to(torch.float32)
+        if init_lora_weights == 'pissa':
+            (V, S, Uh) = torch.linalg.svd(weight.data, full_matrices=False)
+            Vr = V[:, :self.r[adapter_name]]
+            Sr = S[:self.r[adapter_name]]
+            Sr /= self.scaling[adapter_name]
+            Uhr = Uh[:self.r[adapter_name]]
+        elif len(init_lora_weights.split('_niter_')) == 2:
+            (Vr, Sr, Ur) = svd_lowrank(weight.data, self.r[adapter_name], niter=int(init_lora_weights.split('_niter_')[-1]))
+            Sr /= self.scaling[adapter_name]
+            Uhr = Ur.t()
+        else:
+            raise ValueError(f"init_lora_weights should be 'pissa' or 'pissa_niter_[number of iters]', got {init_lora_weights} instead.")
+        lora_A = torch.diag(torch.sqrt(Sr)) @ Uhr
+        lora_B = Vr @ torch.diag(torch.sqrt(Sr))
+        self.lora_A[adapter_name].weight.data = lora_A
+        self.lora_B[adapter_name].weight.data = lora_B
+        weight = weight.data - self.scaling[adapter_name] * lora_B @ lora_A
+        weight = weight.to(dtype)
+        self.get_base_layer().weight.data = weight
+
+    def loftq_init(self, adapter_name):
+        from peft.utils.loftq_utils import loftq_init
+        weight = self.get_base_layer().weight
+        kwargs = {'num_bits': self.kwargs.get('loftq_bits', 4), 'reduced_rank': self.r[adapter_name], 'num_iter': self.kwargs.get('loftq_iter', 1)}
+        (qweight, lora_A, lora_B) = loftq_init(weight, **kwargs)
+        if adapter_name in self.lora_A.keys():
+            self.lora_A[adapter_name].weight.data = lora_A
+            self.lora_B[adapter_name].weight.data = lora_B
+        if adapter_name in self.lora_embedding_A.keys():
+            self.lora_embedding_A[adapter_name].weight.data = lora_A
+            self.lora_embedding_B[adapter_name].weight.data = lora_B
+        self.get_base_layer().weight.data = qweight
+
+    def dora_init(self, adapter_name: str) -> None:
+        if not self.lora_magnitude_vector:
+            self.adapter_layer_names = self.adapter_layer_names[:] + ('lora_magnitude_vector',)
+        dora_layer = DoraLinearLayer(fan_in_fan_out=getattr(self, 'fan_in_fan_out', False))
+        lora_A = self.lora_A[adapter_name].weight
+        lora_B = self.lora_B[adapter_name].weight
+        place_on_cpu = self.ephemeral_gpu_offload and (lora_A.device.type == 'cpu' or lora_B.device.type == 'cpu')
+        if self.ephemeral_gpu_offload:
+            if lora_A.device.type in ['cuda', 'xpu']:
+                lora_B = lora_B.to(lora_A.device)
+            else:
+                if lora_B.device.type not in ['cuda', 'xpu']:
+                    if is_xpu_available():
+                        lora_B = lora_B.to('xpu')
+                    else:
+                        lora_B = lora_B.to('cuda')
+                lora_A = lora_A.to(lora_B.device)
+        scaling = self.scaling[adapter_name]
+        dora_layer.update_layer(base_layer=self.get_base_layer(), lora_A=lora_A, lora_B=lora_B, scaling=scaling, place_on_cpu=place_on_cpu)
+        self.lora_magnitude_vector[adapter_name] = dora_layer
+
+    def _cache_store(self, key: str, value: Any) -> None:
+        self._caches[key] = value
+
+    def _cache_pop(self, key: str) -> Any:
+        value = self._caches.pop(key)
+        return value
+
+    def set_scale(self, adapter, scale):
+        if adapter not in self.scaling:
+            return
+        self.scaling[adapter] = scale * self.lora_alpha[adapter] / self.r[adapter]
+
+    def scale_layer(self, scale: float) -> None:
+        if scale == 1:
+            return
+        for active_adapter in self.active_adapters:
+            if active_adapter not in self.lora_A.keys():
+                continue
+            self.scaling[active_adapter] *= scale
+
+    def unscale_layer(self, scale=None) -> None:
+        for active_adapter in self.active_adapters:
+            if active_adapter not in self.lora_A.keys():
+                continue
+            if scale is None:
+                self.scaling[active_adapter] = self.lora_alpha[active_adapter] / self.r[active_adapter]
+            else:
+                self.scaling[active_adapter] /= scale
+
+    def _check_forward_args(self, x, *args, **kwargs):
+        adapter_names = kwargs.get('adapter_names', None)
+        if adapter_names is None:
+            return
+        if len(x) != len(adapter_names):
+            msg = f'Length of `adapter_names` should be the same as the number of inputs, but got {len(adapter_names)} and {len(x)} respectively.'
+            raise ValueError(msg)
+        if self.merged:
+            msg = 'Cannot pass `adapter_names` when there are merged adapters, please call `unmerge_adapter` first.'
+            raise ValueError(msg)
+        unique_adapters = set(self.active_adapters)
+        for adapter_name in unique_adapters:
+            if self.use_dora.get(adapter_name, False):
+                msg = 'Cannot pass `adapter_names` when DoRA is enabled.'
+                raise ValueError(msg)
+
+    def _mixed_batch_forward(self, x: torch.Tensor, *args: Any, adapter_names: list[str], **kwargs: Any) -> torch.Tensor:
+        result = self.base_layer(x, *args, **kwargs)
+        torch_result_dtype = result.dtype
+        unique_adapters = set(adapter_names)
+        sub_batch_indices_list = []
+        for adapter in unique_adapters:
+            sub_batch_indices_list.append([index for (index, item) in enumerate(adapter_names) if item == adapter])
+        for (i, active_adapter) in enumerate(unique_adapters):
+            if active_adapter == '__base__':
+                continue
+            if active_adapter not in self.lora_A.keys():
+                continue
+            lora_A = self.lora_A[active_adapter]
+            lora_B = self.lora_B[active_adapter]
+            dropout = self.lora_dropout[active_adapter]
+            scaling = self.scaling[active_adapter]
+            sub_batch = x[sub_batch_indices_list[i]].to(lora_A.weight.dtype)
+            lora_output = lora_B(lora_A(dropout(sub_batch))) * scaling
+            result[sub_batch_indices_list[i]] += lora_output.to(torch_result_dtype)
+        return result
+
+class Linear(nn.Module, LoraLayer):
+
+    def __init__(self, base_layer, adapter_name: str, r: int=0, lora_alpha: int=1, lora_dropout: float=0.0, fan_in_fan_out: bool=False, is_target_conv_1d_layer: bool=False, init_lora_weights: Union[bool, str]=True, use_rslora: bool=False, use_dora: bool=False, **kwargs) -> None:
+        super().__init__()
+        LoraLayer.__init__(self, base_layer, **kwargs)
+        self.fan_in_fan_out = fan_in_fan_out
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, lora_alpha=lora_alpha, lora_dropout=lora_dropout, init_lora_weights=init_lora_weights, use_rslora=use_rslora, use_dora=use_dora)
+        self.is_target_conv_1d_layer = is_target_conv_1d_layer
+
+    def merge(self, safe_merge: bool=False, adapter_names: Optional[list[str]]=None) -> None:
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            return
+        for active_adapter in adapter_names:
+            if active_adapter in self.lora_A.keys():
+                base_layer = self.get_base_layer()
+                if safe_merge:
+                    orig_weights = base_layer.weight.data.clone()
+                    delta_weight = self.get_delta_weight(active_adapter)
+                    if not self.use_dora[active_adapter]:
+                        orig_weights += delta_weight
+                    else:
+                        weight_norm = self.lora_magnitude_vector[active_adapter].get_weight_norm(orig_weights, transpose(delta_weight, self.fan_in_fan_out), scaling=1).detach()
+                        self._cache_store(f'{active_adapter}-weight_norm', weight_norm)
+                        dora_factor = self.lora_magnitude_vector[active_adapter].weight / weight_norm
+                        dora_factor = transpose(dora_factor.view(-1, 1), self.fan_in_fan_out)
+                        orig_weights = dora_factor * (orig_weights + delta_weight)
+                    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:
+                    delta_weight = self.get_delta_weight(active_adapter)
+                    if not self.use_dora[active_adapter]:
+                        base_layer.weight.data += delta_weight
+                    else:
+                        weight_norm = self.lora_magnitude_vector[active_adapter].get_weight_norm(base_layer.weight, transpose(delta_weight, self.fan_in_fan_out), scaling=1).detach()
+                        self._cache_store(f'{active_adapter}-weight_norm', weight_norm)
+                        dora_factor = self.lora_magnitude_vector[active_adapter].weight / weight_norm
+                        dora_factor = transpose(dora_factor.view(-1, 1), self.fan_in_fan_out)
+                        new_weight = dora_factor * (base_layer.weight.data + delta_weight)
+                        base_layer.weight.data = new_weight
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        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():
+                weight = self.get_base_layer().weight
+                delta_weight = self.get_delta_weight(active_adapter)
+                if not self.use_dora[active_adapter]:
+                    weight.data -= delta_weight
+                else:
+                    weight_norm = self._cache_pop(f'{active_adapter}-weight_norm')
+                    dora_factor = self.lora_magnitude_vector[active_adapter].weight / weight_norm
+                    weight_orig = weight.data / dora_factor.view(-1, 1) - delta_weight
+                    weight.data = weight_orig
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        device = self.lora_B[adapter].weight.device
+        dtype = self.lora_B[adapter].weight.dtype
+        cast_to_fp32 = device.type == 'cpu' and (dtype == torch.float16 or dtype == torch.bfloat16)
+        weight_A = self.lora_A[adapter].weight
+        weight_B = self.lora_B[adapter].weight
+        if cast_to_fp32:
+            weight_A = weight_A.float()
+            weight_B = weight_B.float()
+        output_tensor = transpose(weight_B @ weight_A, self.fan_in_fan_out) * self.scaling[adapter]
+        if cast_to_fp32:
+            output_tensor = output_tensor.to(dtype=dtype)
+            self.lora_A[adapter].weight.data = weight_A.to(dtype)
+            self.lora_B[adapter].weight.data = weight_B.to(dtype)
+        return output_tensor
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        self._check_forward_args(x, *args, **kwargs)
+        adapter_names = kwargs.pop('adapter_names', None)
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif adapter_names is not None:
+            result = self._mixed_batch_forward(x, *args, adapter_names=adapter_names, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            result = self.base_layer(x, *args, **kwargs)
+            torch_result_dtype = result.dtype
+            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]
+                dropout = self.lora_dropout[active_adapter]
+                scaling = self.scaling[active_adapter]
+                x = x.to(lora_A.weight.dtype)
+                if not self.use_dora[active_adapter]:
+                    result = result + lora_B(lora_A(dropout(x))) * scaling
+                else:
+                    x = dropout(x)
+                    result = result + self.lora_magnitude_vector[active_adapter](x, lora_A=lora_A, lora_B=lora_B, scaling=scaling, base_layer=self.get_base_layer())
+            result = result.to(torch_result_dtype)
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return 'lora.' + rep
+
+class Embedding(nn.Module, LoraLayer):
+
+    def __init__(self, base_layer: nn.Module, adapter_name: str, r: int=0, lora_alpha: int=1, lora_dropout: float=0.0, init_lora_weights: Union[bool, str]=True, use_rslora: bool=False, use_dora: bool=False, **kwargs) -> None:
+        super().__init__()
+        LoraLayer.__init__(self, base_layer)
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, lora_alpha=lora_alpha, lora_dropout=lora_dropout, init_lora_weights=init_lora_weights, use_rslora=use_rslora, use_dora=use_dora)
+
+    def update_layer(self, adapter_name, r, lora_alpha, lora_dropout, init_lora_weights, use_rslora, use_dora):
+        if r <= 0:
+            raise ValueError(f'`r` should be a positive integer value 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
+        weight_A = torch.randn((r, self.in_features))
+        weight_B = torch.randn((self.out_features, r))
+        self.lora_embedding_A[adapter_name] = nn.Parameter(weight_A)
+        self.lora_embedding_B[adapter_name] = nn.Parameter(weight_B)
+        if use_rslora:
+            self.scaling[adapter_name] = lora_alpha / math.sqrt(r)
+        else:
+            self.scaling[adapter_name] = lora_alpha / r
+        if init_lora_weights == 'loftq':
+            self.loftq_init(adapter_name)
+        elif init_lora_weights:
+            self.reset_lora_parameters(adapter_name, init_lora_weights)
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        if use_dora:
+            self.dora_init(adapter_name)
+            self.use_dora[adapter_name] = True
+        else:
+            self.use_dora[adapter_name] = False
+        self.set_adapter(self.active_adapters)
+
+    def dora_init(self, adapter_name: str) -> None:
+        if self.lora_magnitude_vector is None:
+            self.adapter_layer_names = self.adapter_layer_names[:] + ('lora_magnitude_vector',)
+        dora_layer = DoraEmbeddingLayer(fan_in_fan_out=True)
+        lora_embedding_A = self.lora_embedding_A[adapter_name]
+        lora_embedding_B = self.lora_embedding_B[adapter_name]
+        scaling = self.scaling[adapter_name]
+        dora_layer.update_layer(base_layer=self.get_base_layer(), lora_A=lora_embedding_A, lora_B=lora_embedding_B, scaling=scaling)
+        self.lora_magnitude_vector[adapter_name] = dora_layer
+
+    def merge(self, safe_merge: bool=False, adapter_names: Optional[list[str]]=None) -> None:
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            return
+        for active_adapter in adapter_names:
+            if active_adapter in self.lora_embedding_A.keys():
+                base_layer = self.get_base_layer()
+                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:
+        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_embedding_A.keys():
+                self.get_base_layer().weight.data -= self.get_delta_weight(active_adapter)
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        device = self.lora_embedding_B[adapter].device
+        dtype = self.lora_embedding_A[adapter].dtype
+        cast_to_fp32 = device.type == 'cpu' and (dtype == torch.float16 or dtype == torch.bfloat16)
+        weight_A = self.lora_embedding_A[adapter]
+        weight_B = self.lora_embedding_B[adapter]
+        if cast_to_fp32:
+            weight_A = weight_A.float()
+            weight_B = weight_B.float()
+        output_tensor = transpose(weight_B @ weight_A, True) * self.scaling[adapter]
+        if cast_to_fp32:
+            output_tensor = output_tensor.to(dtype=dtype)
+            self.lora_embedding_A[adapter] = weight_A.to(dtype)
+            self.lora_embedding_B[adapter] = weight_B.to(dtype)
+        return output_tensor
+
+    def _mixed_batch_forward(self, x: torch.Tensor, *args: Any, adapter_names: list[str], **kwargs: Any) -> torch.Tensor:
+        result = self.base_layer(x, *args, **kwargs)
+        unique_adapters = set(adapter_names)
+        sub_batch_indices_list = []
+        for adapter in unique_adapters:
+            sub_batch_indices_list.append([index for (index, item) in enumerate(adapter_names) if item == adapter])
+        for (i, active_adapter) in enumerate(unique_adapters):
+            if active_adapter == '__base__':
+                continue
+            if active_adapter not in self.lora_embedding_A.keys():
+                continue
+            embedding_A = self.lora_embedding_A[active_adapter].T
+            embedding_B = self.lora_embedding_B[active_adapter].T
+            scaling = self.scaling[active_adapter]
+            sub_batch = x[sub_batch_indices_list[i]]
+            after_A = self._embed(sub_batch, embedding_A)
+            result[sub_batch_indices_list[i]] += after_A @ embedding_B * scaling
+        return result
+
+    def _embed(self, input: torch.Tensor, weight: torch.Tensor) -> torch.Tensor:
+        base_layer = self.get_base_layer()
+        return F.embedding(input, weight, padding_idx=base_layer.padding_idx, max_norm=base_layer.max_norm, norm_type=base_layer.norm_type, scale_grad_by_freq=base_layer.scale_grad_by_freq, sparse=base_layer.sparse)
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        self._check_forward_args(x, *args, **kwargs)
+        adapter_names = kwargs.pop('adapter_names', None)
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif adapter_names is not None:
+            result = self._mixed_batch_forward(x, *args, adapter_names=adapter_names, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            result = self.base_layer(x, *args, **kwargs)
+            torch_result_dtype = result.dtype
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.lora_embedding_A:
+                    continue
+                embedding_A = self.lora_embedding_A[active_adapter].T
+                embedding_B = self.lora_embedding_B[active_adapter].T
+                scaling = self.scaling[active_adapter]
+                if not self.use_dora[active_adapter]:
+                    after_A = self._embed(x, embedding_A)
+                    result = result + after_A @ embedding_B * scaling
+                else:
+                    (mag_norm_scale, dora_result) = self.lora_magnitude_vector[active_adapter](x, lora_A=embedding_A, lora_B=embedding_B, scaling=scaling, base_layer=self.get_base_layer(), embed_fn=self._embed)
+                    result = mag_norm_scale * result + dora_result
+            result = result.to(torch_result_dtype)
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return 'lora.' + rep
+
+class Conv2d(nn.Module, LoraLayer):
+
+    def __init__(self, base_layer: nn.Module, adapter_name: str, r: int=0, lora_alpha: int=1, lora_dropout: float=0.0, init_lora_weights: Union[bool, str]=True, use_rslora: bool=False, use_dora: bool=False, **kwargs) -> None:
+        super().__init__()
+        LoraLayer.__init__(self, base_layer)
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, lora_alpha=lora_alpha, lora_dropout=lora_dropout, init_lora_weights=init_lora_weights, use_rslora=use_rslora, use_dora=use_dora)
+
+    def update_layer(self, adapter_name, r, lora_alpha, lora_dropout, init_lora_weights, use_rslora, use_dora):
+        if r <= 0:
+            raise ValueError(f'`r` should be a positive integer value 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_layer = self.get_base_layer()
+        kernel_size = base_layer.kernel_size
+        stride = base_layer.stride
+        padding = base_layer.padding
+        self.lora_A[adapter_name] = nn.Conv2d(self.in_features, r, kernel_size, stride, padding, bias=False)
+        self.lora_B[adapter_name] = nn.Conv2d(r, self.out_features, (1, 1), (1, 1), bias=False)
+        if use_rslora:
+            self.scaling[adapter_name] = lora_alpha / math.sqrt(r)
+        else:
+            self.scaling[adapter_name] = lora_alpha / r
+        if init_lora_weights == 'loftq':
+            self.loftq_init(adapter_name)
+        elif init_lora_weights:
+            self.reset_lora_parameters(adapter_name, init_lora_weights)
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        if use_dora:
+            self.dora_init(adapter_name)
+            self.use_dora[adapter_name] = True
+        else:
+            self.use_dora[adapter_name] = False
+        self.set_adapter(self.active_adapters)
+
+    def dora_init(self, adapter_name: str) -> None:
+        if self.lora_magnitude_vector is None:
+            self.adapter_layer_names = self.adapter_layer_names[:] + ('lora_magnitude_vector',)
+        dora_layer = DoraConv2dLayer(fan_in_fan_out=False)
+        lora_A = self.lora_A[adapter_name].weight
+        lora_B = self.lora_B[adapter_name].weight
+        scaling = self.scaling[adapter_name]
+        dora_layer.update_layer(base_layer=self.get_base_layer(), lora_A=lora_A, lora_B=lora_B, scaling=scaling)
+        self.lora_magnitude_vector[adapter_name] = dora_layer
+
+    def merge(self, safe_merge: bool=False, adapter_names: Optional[list[str]]=None) -> None:
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            return
+        for active_adapter in adapter_names:
+            if active_adapter in self.lora_A.keys():
+                base_layer = self.get_base_layer()
+                if safe_merge:
+                    orig_weights = base_layer.weight.data.clone()
+                    delta_weight = self.get_delta_weight(active_adapter)
+                    if not self.use_dora[active_adapter]:
+                        orig_weights += delta_weight
+                    else:
+                        weight_norm = self.lora_magnitude_vector[active_adapter].get_weight_norm(orig_weights, delta_weight, scaling=1).detach()
+                        self._cache_store(f'{active_adapter}-weight_norm', weight_norm)
+                        dora_factor = self.lora_magnitude_vector[active_adapter].weight / weight_norm
+                        orig_weights = dora_factor.view(-1, 1, 1, 1) * (orig_weights + delta_weight)
+                    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:
+                    delta_weight = self.get_delta_weight(active_adapter)
+                    if not self.use_dora[active_adapter]:
+                        base_layer.weight.data += delta_weight
+                    else:
+                        weight_norm = self.lora_magnitude_vector[active_adapter].get_weight_norm(base_layer.weight, delta_weight, scaling=1).detach()
+                        self._cache_store(f'{active_adapter}-weight_norm', weight_norm)
+                        dora_factor = self.lora_magnitude_vector[active_adapter].weight / weight_norm
+                        new_weight = dora_factor.view(-1, 1, 1, 1) * (base_layer.weight.data + delta_weight)
+                        base_layer.weight.data = new_weight
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        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():
+                weight = self.get_base_layer().weight
+                delta_weight = self.get_delta_weight(active_adapter)
+                if not self.use_dora[active_adapter]:
+                    weight.data -= delta_weight
+                else:
+                    weight_norm = self._cache_pop(f'{active_adapter}-weight_norm')
+                    dora_factor = self.lora_magnitude_vector[active_adapter].weight / weight_norm
+                    weight_orig = weight.data / dora_factor.view(-1, 1, 1, 1) - delta_weight
+                    weight.data = weight_orig
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        device = self.lora_B[adapter].weight.device
+        dtype = self.lora_A[adapter].weight.dtype
+        cast_to_fp32 = device.type == 'cpu' and (dtype == torch.float16 or dtype == torch.bfloat16)
+        weight_A = self.lora_A[adapter].weight
+        weight_B = self.lora_B[adapter].weight
+        if cast_to_fp32:
+            weight_A = weight_A.float()
+            weight_B = weight_B.float()
+        if self.get_base_layer().weight.size()[2:4] == (1, 1):
+            output_tensor = (weight_B.squeeze(3).squeeze(2) @ weight_A.squeeze(3).squeeze(2)).unsqueeze(2).unsqueeze(3) * self.scaling[adapter]
+        else:
+            output_tensor = F.conv2d(weight_A.permute(1, 0, 2, 3), weight_B).permute(1, 0, 2, 3) * self.scaling[adapter]
+        if cast_to_fp32:
+            output_tensor = output_tensor.to(dtype=dtype)
+            self.lora_A[adapter].weight.data = weight_A.to(dtype)
+            self.lora_B[adapter].weight.data = weight_B.to(dtype)
+        return output_tensor
+
+    def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+        self._check_forward_args(x, *args, **kwargs)
+        adapter_names = kwargs.pop('adapter_names', None)
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif adapter_names is not None:
+            result = self._mixed_batch_forward(x, *args, adapter_names=adapter_names, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            result = self.base_layer(x, *args, **kwargs)
+            torch_result_dtype = result.dtype
+            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]
+                dropout = self.lora_dropout[active_adapter]
+                scaling = self.scaling[active_adapter]
+                x = x.to(lora_A.weight.dtype)
+                if not self.use_dora[active_adapter]:
+                    result = result + lora_B(lora_A(dropout(x))) * scaling
+                else:
+                    x = dropout(x)
+                    result = result + self.lora_magnitude_vector[active_adapter](x, lora_A=lora_A, lora_B=lora_B, scaling=scaling, base_layer=self.get_base_layer())
+            result = result.to(torch_result_dtype)
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return 'lora.' + rep
+
+def dispatch_default(target: torch.nn.Module, adapter_name: str, lora_config: LoraConfig, **kwargs) -> Optional[torch.nn.Module]:
+    new_module = None
+    if isinstance(target, BaseTunerLayer):
+        target_base_layer = target.get_base_layer()
+    else:
+        target_base_layer = target
+    if isinstance(target_base_layer, torch.nn.Embedding):
+        embedding_kwargs = kwargs.copy()
+        embedding_kwargs.pop('fan_in_fan_out', None)
+        embedding_kwargs.update(lora_config.loftq_config)
+        new_module = Embedding(target, adapter_name, **embedding_kwargs)
+    elif isinstance(target_base_layer, torch.nn.Conv2d):
+        kwargs.update(lora_config.loftq_config)
+        new_module = Conv2d(target, adapter_name, **kwargs)
+    elif isinstance(target_base_layer, torch.nn.Linear):
+        if kwargs['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.')
+            kwargs['fan_in_fan_out'] = lora_config.fan_in_fan_out = False
+        kwargs.update(lora_config.loftq_config)
+        new_module = Linear(target, adapter_name, **kwargs)
+    elif isinstance(target_base_layer, Conv1D):
+        if not kwargs['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.')
+            kwargs['fan_in_fan_out'] = lora_config.fan_in_fan_out = True
+        kwargs.update(lora_config.loftq_config)
+        new_module = Linear(target, adapter_name, is_target_conv_1d_layer=True, **kwargs)
+    return new_module
+
+# File: peft-main/src/peft/tuners/lora/model.py
+from __future__ import annotations
+import math
+import operator
+import re
+import warnings
+from contextlib import contextmanager
+from dataclasses import asdict, replace
+from enum import Enum
+from functools import partial, reduce
+from itertools import chain
+from typing import Literal, Optional
+import torch
+from torch import nn
+from tqdm import tqdm
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer, check_target_module_exists, onload_layer, replicate_layers
+from peft.utils import TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING, ModulesToSaveWrapper, _freeze_adapter, _get_submodules, get_peft_model_state_dict, get_quantization_config
+from peft.utils.merge_utils import dare_linear, dare_ties, magnitude_prune, task_arithmetic, ties
+from .aqlm import dispatch_aqlm
+from .awq import dispatch_awq
+from .config import LoraConfig
+from .eetq import dispatch_eetq
+from .gptq import dispatch_gptq
+from .hqq import dispatch_hqq
+from .layer import Conv2d, LoraLayer, dispatch_default
+from .tp_layer import dispatch_megatron
+
+def _adapter_names_pre_forward_hook(target, args, kwargs, adapter_names):
+    kwargs['adapter_names'] = adapter_names
+    return (args, kwargs)
+
+class LoraModel(BaseTuner):
+    prefix: str = 'lora_'
+
+    def __init__(self, model, config, adapter_name) -> None:
+        super().__init__(model, config, adapter_name)
+
+    def _check_new_adapter_config(self, config: LoraConfig) -> None:
+        if len(self.peft_config) > 1 and config.bias != 'none':
+            raise ValueError(f"{self.__class__.__name__} supports only 1 adapter with bias. When using multiple adapters, set bias to 'none' for all adapters.")
+
+    @staticmethod
+    def _check_target_module_exists(lora_config, key):
+        return check_target_module_exists(lora_config, key)
+
+    def _prepare_model(self, peft_config: LoraConfig, model: nn.Module):
+        if peft_config.layer_replication:
+            replicate_layers(model, peft_config.layer_replication)
+
+    def _create_and_replace(self, lora_config, adapter_name, target, target_name, parent, current_key):
+        if current_key is None:
+            raise ValueError("Current Key shouldn't be `None`")
+        pattern_keys = list(chain(lora_config.rank_pattern.keys(), lora_config.alpha_pattern.keys()))
+        target_name_key = next(filter(lambda key: re.match(f'.*\\.{key}$', current_key), pattern_keys), current_key)
+        r = lora_config.rank_pattern.get(target_name_key, lora_config.r)
+        alpha = lora_config.alpha_pattern.get(target_name_key, lora_config.lora_alpha)
+        kwargs = {'r': r, 'lora_alpha': alpha, 'lora_dropout': lora_config.lora_dropout, 'fan_in_fan_out': lora_config.fan_in_fan_out, 'init_lora_weights': lora_config.init_lora_weights, 'use_rslora': lora_config.use_rslora, 'use_dora': lora_config.use_dora, 'ephemeral_gpu_offload': lora_config.runtime_config.ephemeral_gpu_offload, 'loaded_in_8bit': getattr(self.model, 'is_loaded_in_8bit', False), 'loaded_in_4bit': getattr(self.model, 'is_loaded_in_4bit', False)}
+        quant_methods = ['gptq', 'aqlm', 'awq']
+        for quant_method in quant_methods:
+            quantization_config = get_quantization_config(self.model, method=quant_method)
+            if quantization_config is not None:
+                kwargs[f'{quant_method}_quantization_config'] = quantization_config
+        from peft.tuners.adalora import AdaLoraLayer
+        if isinstance(target, LoraLayer) and (not isinstance(target, AdaLoraLayer)):
+            target.update_layer(adapter_name, r, lora_alpha=alpha, lora_dropout=lora_config.lora_dropout, init_lora_weights=lora_config.init_lora_weights, use_rslora=lora_config.use_rslora, use_dora=lora_config.use_dora)
+        else:
+            new_module = self._create_new_module(lora_config, adapter_name, target, **kwargs)
+            if adapter_name not in self.active_adapters:
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+
+    def _replace_module(self, parent, child_name, new_module, child):
+        setattr(parent, child_name, new_module)
+        if hasattr(child, 'base_layer'):
+            child = child.base_layer
+        if not hasattr(new_module, 'base_layer'):
+            if hasattr(new_module, 'W_q'):
+                new_module.W_q = child.W_q
+            else:
+                new_module.weight = child.weight
+            if hasattr(child, 'bias'):
+                new_module.bias = child.bias
+        if getattr(child, 'state', None) is not None:
+            if hasattr(new_module, 'base_layer'):
+                new_module.base_layer.state = child.state
+            else:
+                new_module.state = child.state
+            new_module.to(child.weight.device)
+        for (name, module) in new_module.named_modules():
+            if self.prefix in name or 'ranknum' in name:
+                weight = child.qweight if hasattr(child, 'qweight') else child.W_q if hasattr(child, 'W_q') else child.weight if hasattr(child, 'weight') else next(child.parameters())
+                module.to(weight.device)
+
+    def _mark_only_adapters_as_trainable(self, model: nn.Module) -> None:
+        for (n, p) in model.named_parameters():
+            if self.prefix not in n:
+                p.requires_grad = False
+        for active_adapter in self.active_adapters:
+            bias = self.peft_config[active_adapter].bias
+            if bias == 'none':
+                continue
+            if bias == 'all':
+                for (n, p) in model.named_parameters():
+                    if 'bias' in n:
+                        p.requires_grad = True
+            elif bias == 'lora_only':
+                for m in model.modules():
+                    if isinstance(m, LoraLayer) and hasattr(m, 'bias') and (m.bias is not None):
+                        m.bias.requires_grad = True
+            else:
+                raise NotImplementedError(f'Requested bias: {bias}, is not implemented.')
+
+    @staticmethod
+    def _create_new_module(lora_config, adapter_name, target, **kwargs):
+        dispatchers = []
+        if lora_config._custom_modules:
+
+            def dynamic_dispatch_func(target, adapter_name, lora_config, **kwargs):
+                new_module = None
+                if isinstance(target, BaseTunerLayer):
+                    target_base_layer = target.get_base_layer()
+                else:
+                    target_base_layer = target
+                for (key, custom_cls) in lora_config._custom_modules.items():
+                    if isinstance(target_base_layer, key):
+                        new_module = custom_cls(target, adapter_name, **kwargs)
+                        break
+                return new_module
+            dispatchers.append(dynamic_dispatch_func)
+        if is_bnb_available():
+            from .bnb import dispatch_bnb_8bit
+            dispatchers.append(dispatch_bnb_8bit)
+        if is_bnb_4bit_available():
+            from .bnb import dispatch_bnb_4bit
+            dispatchers.append(dispatch_bnb_4bit)
+        dispatchers.extend([dispatch_eetq, dispatch_aqlm, dispatch_awq, dispatch_gptq, dispatch_hqq, dispatch_megatron, dispatch_default])
+        new_module = None
+        for dispatcher in dispatchers:
+            new_module = dispatcher(target, adapter_name, lora_config=lora_config, **kwargs)
+            if new_module is not None:
+                break
+        if new_module is None:
+            raise ValueError(f'Target module {target} is not supported. Currently, only the following modules are supported: `torch.nn.Linear`, `torch.nn.Embedding`, `torch.nn.Conv2d`, `transformers.pytorch_utils.Conv1D`.')
+        return new_module
+
+    def __getattr__(self, name: str):
+        try:
+            return super().__getattr__(name)
+        except AttributeError:
+            if name == 'model':
+                raise
+            return getattr(self.model, name)
+
+    def get_peft_config_as_dict(self, inference: bool=False):
+        config_dict = {}
+        for (key, value) in self.peft_config.items():
+            config = {k: v.value if isinstance(v, Enum) else v for (k, v) in asdict(value).items()}
+            if inference:
+                config['inference_mode'] = True
+        config_dict[key] = config
+        return config
+
+    def _set_adapter_layers(self, enabled: bool=True) -> None:
+        for module in self.model.modules():
+            if isinstance(module, (BaseTunerLayer, ModulesToSaveWrapper)):
+                module.enable_adapters(enabled)
+
+    def enable_adapter_layers(self) -> None:
+        self._set_adapter_layers(enabled=True)
+
+    def disable_adapter_layers(self) -> None:
+        for active_adapter in self.active_adapters:
+            val = self.peft_config[active_adapter].bias
+            if val != 'none':
+                msg = f"Careful, disabling adapter layers with bias configured to be '{val}' does not produce the same output as the the base model would without adaption."
+                warnings.warn(msg)
+        self._set_adapter_layers(enabled=False)
+
+    def set_adapter(self, adapter_name: str | list[str]) -> None:
+        for module in self.model.modules():
+            if isinstance(module, LoraLayer):
+                if module.merged:
+                    warnings.warn('Adapter cannot be set when the model is merged. Unmerging the model first.')
+                    module.unmerge()
+                module.set_adapter(adapter_name)
+        self.active_adapter = adapter_name
+
+    @contextmanager
+    def _enable_peft_forward_hooks(self, *args, **kwargs):
+        adapter_names = kwargs.pop('adapter_names', None)
+        if adapter_names is None:
+            yield
+            return
+        if self.training:
+            raise ValueError('Cannot pass `adapter_names` when the model is in training mode.')
+        hook_handles = []
+        for module in self.modules():
+            if isinstance(module, LoraLayer):
+                pre_forward = partial(_adapter_names_pre_forward_hook, adapter_names=adapter_names)
+                handle = module.register_forward_pre_hook(pre_forward, with_kwargs=True)
+                hook_handles.append(handle)
+        yield
+        for handle in hook_handles:
+            handle.remove()
+
+    def _check_merge_allowed(self):
+        super()._check_merge_allowed()
+        if getattr(self.model, 'quantization_method', None) == 'gptq':
+            raise ValueError('Cannot merge LORA layers when the model is gptq quantized')
+        if self.peft_config.get('layer_replication'):
+            raise ValueError('Cannot merge LORA layers when base model layers are replicated')
+
+    @staticmethod
+    def _prepare_adapter_config(peft_config, model_config):
+        if peft_config.target_modules is None:
+            if model_config['model_type'] not in TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING:
+                raise ValueError('Please specify `target_modules` in `peft_config`')
+            peft_config.target_modules = set(TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING[model_config['model_type']])
+        return peft_config
+
+    def _unload_and_optionally_merge(self, merge=True, progressbar: bool=False, safe_merge: bool=False, adapter_names: Optional[list[str]]=None):
+        if merge:
+            self._check_merge_allowed()
+        key_list = [key for (key, _) in self.model.named_modules() if self.prefix not in key]
+        desc = 'Unloading ' + ('and merging ' if merge else '') + 'model'
+        for key in tqdm(key_list, disable=not progressbar, desc=desc):
+            try:
+                (parent, target, target_name) = _get_submodules(self.model, key)
+            except AttributeError:
+                continue
+            with onload_layer(target):
+                if hasattr(target, 'base_layer'):
+                    if merge:
+                        target.merge(safe_merge=safe_merge, adapter_names=adapter_names)
+                    self._replace_module(parent, target_name, target.get_base_layer(), target)
+                elif isinstance(target, ModulesToSaveWrapper):
+                    new_module = target.modules_to_save[target.active_adapter]
+                    if hasattr(new_module, 'base_layer'):
+                        if merge:
+                            new_module.merge(safe_merge=safe_merge, adapter_names=adapter_names)
+                        new_module = new_module.get_base_layer()
+                    setattr(parent, target_name, new_module)
+        return self.model
+
+    def _check_add_weighted_adapter(self, adapters: list[str], combination_type: str, svd_rank: int | None) -> tuple[str, int, str]:
+        for adapter in adapters:
+            if adapter not in list(self.peft_config.keys()):
+                raise ValueError(f'Adapter {adapter} does not exist')
+        modules_to_save_wrappers = [module for module in self.modules() if isinstance(module, ModulesToSaveWrapper)]
+        problematic_wrappers = [wrapper for wrapper in modules_to_save_wrappers if sum((adapter in wrapper.modules_to_save for adapter in adapters)) > 1]
+        if problematic_wrappers:
+            raise ValueError(f'Cannot add weighted adapters if they target the same module with modules_to_save, but found {len(problematic_wrappers)} such instance(s).')
+        combination_type = 'linear' if len(adapters) == 1 else combination_type
+        adapters_ranks = [self.peft_config[adapter].r for adapter in adapters]
+        if combination_type in ('linear', 'ties', 'dare_ties', 'dare_linear', 'magnitude_prune'):
+            if len(set(adapters_ranks)) != 1:
+                raise ValueError('All adapters must have the same r value when using combination_type linear, ties, dare_ties or dare_linear.')
+            new_rank = adapters_ranks[0]
+        elif combination_type == 'cat':
+            new_rank = sum(adapters_ranks)
+        elif combination_type.endswith('svd'):
+            new_rank = svd_rank or max(adapters_ranks)
+        else:
+            raise ValueError(f'Invalid combination_type: {combination_type}')
+        target_module_types = [type(self.peft_config[adapter].target_modules) for adapter in adapters]
+        if not target_module_types:
+            raise ValueError(f'Found no adapter matching the names in {adapters}')
+        if len(set(target_module_types)) > 1:
+            raise ValueError('all adapter configs should follow the same target modules type. Combining adapters with `target_modules` type being a mix of list/set and string is not supported.')
+        if target_module_types[0] is str:
+            new_target_modules = '|'.join((f'({self.peft_config[adapter].target_modules})' for adapter in adapters))
+        elif target_module_types[0] is set:
+            new_target_modules = reduce(operator.or_, (self.peft_config[adapter].target_modules for adapter in adapters))
+        else:
+            raise TypeError(f'Invalid type {target_module_types[0]} found in target_modules')
+        return (combination_type, new_rank, new_target_modules)
+
+    def add_weighted_adapter(self, adapters: list[str], weights: list[float], adapter_name: str, combination_type: str='svd', svd_rank: int | None=None, svd_clamp: int | None=None, svd_full_matrices: bool=True, svd_driver: str | None=None, density: float | None=None, majority_sign_method: Literal['total', 'frequency']='total') -> None:
+        if adapter_name in list(self.peft_config.keys()):
+            return
+        (combination_type, new_rank, new_target_modules) = self._check_add_weighted_adapter(adapters=adapters, combination_type=combination_type, svd_rank=svd_rank)
+        self.peft_config[adapter_name] = replace(self.peft_config[adapters[0]], r=new_rank, lora_alpha=new_rank, target_modules=new_target_modules)
+        self.inject_adapter(self.model, adapter_name)
+        _freeze_adapter(self.model, adapter_name)
+        key_list = [key for (key, _) in self.model.named_modules() if self.prefix not in key]
+        for key in key_list:
+            (_, target, _) = _get_submodules(self.model, key)
+            if isinstance(target, LoraLayer):
+                if adapter_name in target.lora_A:
+                    target_lora_A = target.lora_A[adapter_name].weight
+                    target_lora_B = target.lora_B[adapter_name].weight
+                elif adapter_name in target.lora_embedding_A:
+                    target_lora_A = target.lora_embedding_A[adapter_name]
+                    target_lora_B = target.lora_embedding_B[adapter_name]
+                else:
+                    continue
+                target_lora_A.data = target_lora_A.data * 0.0
+                target_lora_B.data = target_lora_B.data * 0.0
+                if combination_type == 'cat':
+                    (loras_A, loras_B) = ([], [])
+                    for (adapter, weight) in zip(adapters, weights):
+                        if adapter in target.lora_A:
+                            current_adapter_lora_A = target.lora_A[adapter].weight
+                            current_adapter_lora_B = target.lora_B[adapter].weight
+                        elif adapter in target.lora_embedding_A:
+                            current_adapter_lora_A = target.lora_embedding_A[adapter]
+                            current_adapter_lora_B = target.lora_embedding_B[adapter]
+                        else:
+                            continue
+                        loras_A.append(current_adapter_lora_A.data * weight * target.scaling[adapter])
+                        loras_B.append(current_adapter_lora_B.data)
+                    if len(loras_A) == 0:
+                        raise ValueError('No matching LoRAs found. Please raise an issue on GitHub.')
+                    loras_A = torch.cat(loras_A, dim=0)
+                    loras_B = torch.cat(loras_B, dim=1)
+                    target_lora_A.data[:loras_A.shape[0], :] = loras_A
+                    target_lora_B.data[:, :loras_B.shape[1]] = loras_B
+                elif combination_type in ['svd', 'ties_svd', 'dare_linear_svd', 'dare_ties_svd', 'magnitude_prune_svd']:
+                    (target_lora_A.data, target_lora_B.data) = self._svd_generalized_task_arithmetic_weighted_adapter(combination_type, adapters, weights, new_rank, target, target_lora_A, target_lora_B, density, majority_sign_method, svd_clamp, full_matrices=svd_full_matrices, driver=svd_driver)
+                elif combination_type in ['linear', 'ties', 'dare_linear', 'dare_ties', 'magnitude_prune']:
+                    (target_lora_A.data, target_lora_B.data) = self._generalized_task_arithmetic_weighted_adapter(combination_type, adapters, weights, target, density, majority_sign_method)
+
+    def _svd_generalized_task_arithmetic_weighted_adapter(self, combination_type, adapters, weights, new_rank, target, target_lora_A, target_lora_B, density, majority_sign_method, clamp=None, full_matrices=True, driver=None):
+        valid_adapters = []
+        valid_weights = []
+        is_embedding = any((adapter in target.lora_embedding_A for adapter in adapters))
+        for (adapter, weight) in zip(adapters, weights):
+            if adapter in target.lora_A or adapter in target.lora_embedding_A:
+                valid_adapters.append(adapter)
+                valid_weights.append(weight * target.scaling[adapter])
+        if len(valid_adapters) == 0:
+            raise ValueError('No matching LoRAs found. Please raise an issue on Github.')
+        delta_weight = [target.get_delta_weight(adapter) for adapter in valid_adapters]
+        valid_weights = torch.tensor(valid_weights).to(delta_weight[0].device)
+        if combination_type == 'svd':
+            delta_weight = task_arithmetic(delta_weight, valid_weights)
+        elif combination_type == 'ties_svd':
+            delta_weight = ties(delta_weight, valid_weights, density, majority_sign_method)
+        elif combination_type == 'dare_linear_svd':
+            delta_weight = dare_linear(delta_weight, valid_weights, density)
+        elif combination_type == 'dare_ties_svd':
+            delta_weight = dare_ties(delta_weight, valid_weights, density, majority_sign_method)
+        elif combination_type == 'magnitude_prune_svd':
+            delta_weight = magnitude_prune(delta_weight, valid_weights, density)
+        else:
+            raise ValueError(f'Invalid value passed to combination type: {combination_type}')
+        conv2d = isinstance(target, Conv2d)
+        if conv2d:
+            conv2d_1x1 = target.weight.size()[2:4] == (1, 1)
+            if not conv2d_1x1:
+                delta_weight = delta_weight.flatten(start_dim=1)
+            else:
+                delta_weight = delta_weight.squeeze()
+        if hasattr(target, 'fan_in_fan_out') and target.fan_in_fan_out or is_embedding:
+            delta_weight = delta_weight.T
+        (U, S, Vh) = torch.linalg.svd(delta_weight, full_matrices=full_matrices, driver=driver)
+        U = U[:, :new_rank]
+        S = S[:new_rank]
+        U = U @ torch.diag(S)
+        Vh = Vh[:new_rank, :]
+        if clamp is not None:
+            dist = torch.cat([U.flatten(), Vh.flatten()])
+            hi_val = torch.quantile(dist, clamp)
+            low_val = -hi_val
+            U = U.clamp(low_val, hi_val)
+            Vh = Vh.clamp(low_val, hi_val)
+        if conv2d:
+            U = U.reshape(target_lora_B.data.shape)
+            Vh = Vh.reshape(target_lora_A.data.shape)
+        return (Vh, U)
+
+    def _generalized_task_arithmetic_weighted_adapter(self, combination_type, adapters, weights, target, density, majority_sign_method):
+        valid_weights = []
+        lora_A_deltas = []
+        lora_B_deltas = []
+        for (adapter, weight) in zip(adapters, weights):
+            if adapter in target.lora_A:
+                current_adapter_lora_A = target.lora_A[adapter].weight
+                current_adapter_lora_B = target.lora_B[adapter].weight
+            elif adapter in target.lora_embedding_A:
+                current_adapter_lora_A = target.lora_embedding_A[adapter]
+                current_adapter_lora_B = target.lora_embedding_B[adapter]
+            else:
+                continue
+            valid_weights.append(math.sqrt(weight * target.scaling[adapter]))
+            lora_A_deltas.append(current_adapter_lora_A.data)
+            lora_B_deltas.append(current_adapter_lora_B.data)
+        valid_weights = torch.tensor(valid_weights).to(lora_A_deltas[0].device)
+        lora_deltas = [lora_A_deltas, lora_B_deltas]
+        dtype = lora_A_deltas[0].dtype
+        for (i, task_tensors) in enumerate(lora_deltas):
+            if combination_type == 'linear':
+                lora_deltas[i] = task_arithmetic(task_tensors, valid_weights)
+            elif combination_type == 'ties':
+                lora_deltas[i] = ties(task_tensors, valid_weights, density, majority_sign_method)
+            elif combination_type == 'dare_linear':
+                lora_deltas[i] = dare_linear(task_tensors, valid_weights, density)
+            elif combination_type == 'dare_ties':
+                lora_deltas[i] = dare_ties(task_tensors, valid_weights, density, majority_sign_method)
+            elif combination_type == 'magnitude_prune':
+                lora_deltas[i] = magnitude_prune(task_tensors, valid_weights, density)
+            else:
+                raise ValueError('Invalid combination type')
+        lora_deltas = [delta.to(dtype) for delta in lora_deltas]
+        return lora_deltas
+
+    def delete_adapter(self, adapter_name: str) -> None:
+        if adapter_name not in list(self.peft_config.keys()):
+            raise ValueError(f'Adapter {adapter_name} does not exist')
+        del self.peft_config[adapter_name]
+        key_list = [key for (key, _) in self.model.named_modules() if self.prefix not in key]
+        new_adapter = None
+        for key in key_list:
+            (_, target, _) = _get_submodules(self.model, key)
+            if isinstance(target, LoraLayer):
+                target.delete_adapter(adapter_name)
+                if new_adapter is None:
+                    new_adapter = target.active_adapters[:]
+        self.active_adapter = new_adapter or []
+
+    def merge_and_unload(self, progressbar: bool=False, safe_merge: bool=False, adapter_names: Optional[list[str]]=None) -> torch.nn.Module:
+        return self._unload_and_optionally_merge(progressbar=progressbar, safe_merge=safe_merge, adapter_names=adapter_names)
+
+    def unload(self) -> torch.nn.Module:
+        return self._unload_and_optionally_merge(merge=False)
+
+    def subtract_mutated_init(self, output_state_dict: dict[str, torch.Tensor], adapter_name: str, kwargs=None):
+        for (name, param) in self.model.named_parameters():
+            if (param.data.dtype != torch.float32 and param.data.dtype != torch.float16 and (param.data.dtype != torch.bfloat16)) and adapter_name.startswith('pissa'):
+                warnings.warn('Note that Quant(W_res) + AB != Quant(W) + \\Delta(AB); the converted LoRA, when combined with W or Quant(W), may introduce a certain gap in the fine-tuned model. Therefore, we recommend directly using the Quant(W_res) in conjunction with the PiSSA adapter. ')
+        mutated_init_state_dict = get_peft_model_state_dict(self, state_dict=kwargs.get('state_dict', None), adapter_name=adapter_name)
+        tensors_lora = {}
+        for name in output_state_dict.keys():
+            if 'lora_A' in name:
+                tensors_lora[name] = torch.cat([output_state_dict[name], mutated_init_state_dict['.'.join(name.split('.')[1:])]], dim=0)
+            elif 'lora_B' in name:
+                tensors_lora[name] = torch.cat([output_state_dict[name], -mutated_init_state_dict['.'.join(name.split('.')[1:])]], dim=1)
+        return tensors_lora
+
+# File: peft-main/src/peft/tuners/lora/tp_layer.py
+from __future__ import annotations
+import importlib
+import math
+import warnings
+from typing import Any, Optional, Union
+import torch
+import torch.nn as nn
+import torch.nn.init as init
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+from peft.utils import transpose
+from peft.utils.integrations import gather_params_ctx
+from .layer import LoraLayer
+
+class LoraParallelLinear(nn.Module, LoraLayer):
+
+    def __init__(self, base_layer, adapter_name: str, backend, r: int=0, lora_alpha: int=1, lora_dropout: float=0.0, fan_in_fan_out: bool=False, is_target_conv_1d_layer: bool=False, init_lora_weights: Union[bool, str]=True, use_rslora: bool=False, use_dora: bool=False, **kwargs):
+        super().__init__()
+        LoraLayer.__init__(self, base_layer=base_layer, **kwargs)
+        if use_dora:
+            raise ValueError(f'{self.__class__.__name__} does not support DoRA yet, please set it to False')
+        self.backend = backend
+        self.is_parallel_a = isinstance(base_layer, backend.RowParallelLinear)
+        self.fan_in_fan_out = fan_in_fan_out
+        self._active_adapter = adapter_name
+        megatron_config = kwargs['megatron_config']
+        parallel_linear_kwargs = {'megatron_config': megatron_config}
+        init_method = init.xavier_normal_
+        if hasattr(megatron_config, 'init_method'):
+            init_method = megatron_config.init_method
+        input_is_parallel = True
+        gather_output = False
+        if isinstance(base_layer, self.backend.RowParallelLinear):
+            input_is_parallel = base_layer.input_is_parallel
+        else:
+            gather_output = base_layer.gather_output
+        self.update_layer(adapter_name, r, lora_alpha=lora_alpha, lora_dropout=lora_dropout, init_lora_weights=init_lora_weights, use_rslora=use_rslora, use_dora=use_dora, init_method=init_method, input_is_parallel=input_is_parallel, gather_output=gather_output, **parallel_linear_kwargs)
+        if is_target_conv_1d_layer:
+            raise ValueError(f'{self.__class__.__name__} does not support target_conv_1d_layer yet, please set it to False')
+        self.is_target_conv_1d_layer = False
+
+    def update_layer(self, adapter_name, r, lora_alpha, lora_dropout, init_lora_weights, use_rslora, use_dora=False, init_method=init.xavier_normal_, input_is_parallel=True, gather_output=False, **parallel_linear_kwargs):
+        if r <= 0:
+            raise ValueError(f'`r` should be a positive integer value 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
+        megatron_config = parallel_linear_kwargs['megatron_config']
+        megatron_config.params_dtype = torch.float32
+        if self.is_parallel_a:
+            lora_a = self.backend.RowParallelLinear(input_size=self.in_features, output_size=r, bias=False, input_is_parallel=input_is_parallel, skip_bias_add=True, init_method=init_method, config=megatron_config)
+            lora_b = nn.Linear(in_features=r, out_features=self.out_features, bias=False, dtype=torch.float32)
+        else:
+            lora_a = nn.Linear(in_features=self.in_features, out_features=r, bias=False, dtype=torch.float32)
+            lora_b = self.backend.ColumnParallelLinear(input_size=r, output_size=self.out_features, bias=False, gather_output=gather_output, init_method=init_method, config=megatron_config)
+        self.lora_A[adapter_name] = lora_a
+        self.lora_B[adapter_name] = lora_b
+        if use_rslora:
+            self.scaling[adapter_name] = lora_alpha / math.sqrt(r)
+        else:
+            self.scaling[adapter_name] = lora_alpha / r
+        if isinstance(init_lora_weights, str) and init_lora_weights.startswith('pissa'):
+            with gather_params_ctx(self.get_base_layer().weight):
+                self.pissa_init(adapter_name, init_lora_weights)
+        elif isinstance(init_lora_weights, str) and init_lora_weights.lower() == 'olora':
+            with gather_params_ctx(self.get_base_layer().weight):
+                self.olora_init(adapter_name)
+        elif init_lora_weights == 'loftq':
+            with gather_params_ctx(self.get_base_layer().weight):
+                self.loftq_init(adapter_name)
+        elif init_lora_weights:
+            self.reset_lora_parameters(adapter_name, init_lora_weights)
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        if use_dora:
+            self.dora_init(adapter_name)
+            self.use_dora[adapter_name] = True
+        else:
+            self.use_dora[adapter_name] = False
+        self.set_adapter(self.active_adapters)
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any):
+        self._check_forward_args(x, *args, **kwargs)
+        adapter_names = kwargs.pop('adapter_names', None)
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            (result, bias) = self.base_layer(x, *args, **kwargs)
+        elif adapter_names is not None:
+            raise ValueError(f'{self.__class__.__name__} does not support mixed_batch_forward yet.')
+        elif self.merged:
+            (result, bias) = self.base_layer(x, *args, **kwargs)
+        else:
+            (result, bias) = self.base_layer(x, *args, **kwargs)
+            torch_result_dtype = result.dtype
+            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]
+                dropout = self.lora_dropout[active_adapter]
+                scaling = self.scaling[active_adapter]
+                x = x.to(lora_A.weight.dtype)
+                if not self.use_dora[active_adapter]:
+                    lora_result = lora_A(dropout(x))
+                    if isinstance(lora_result, tuple):
+                        lora_result = lora_result[0]
+                    lora_result = lora_B(lora_result)
+                    if isinstance(lora_result, tuple):
+                        lora_result = lora_result[0]
+                    lora_result = lora_result * scaling
+                    result = result + lora_result
+                else:
+                    x = dropout(x)
+                    result = result + self.lora_magnitude_vector[active_adapter](x, lora_A=lora_A, lora_B=lora_B, scaling=scaling, base_layer=self.get_base_layer())
+            result = result.to(torch_result_dtype)
+        return (result, bias)
+
+    def merge(self, safe_merge: bool=False, adapter_names: Optional[list[str]]=None) -> None:
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            return
+        for active_adapter in adapter_names:
+            if active_adapter in self.lora_A.keys():
+                base_layer = self.get_base_layer()
+                if safe_merge:
+                    orig_weights = base_layer.weight.data.clone()
+                    delta_weight = self.get_delta_weight(active_adapter)
+                    if not self.use_dora[active_adapter]:
+                        orig_weights = orig_weights + delta_weight
+                    else:
+                        weight_norm = self.lora_magnitude_vector[active_adapter].get_weight_norm(orig_weights, transpose(delta_weight, self.fan_in_fan_out), scaling=1).detach()
+                        self._cache_store(f'{active_adapter}-weight_norm', weight_norm)
+                        dora_factor = self.lora_magnitude_vector[active_adapter].weight / weight_norm
+                        dora_factor = transpose(dora_factor.view(-1, 1), self.fan_in_fan_out)
+                        orig_weights = dora_factor * (orig_weights + delta_weight)
+                    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:
+                    delta_weight = self.get_delta_weight(active_adapter)
+                    if not self.use_dora[active_adapter]:
+                        base_layer.weight.data = base_layer.weight.data + delta_weight
+                    else:
+                        weight_norm = self.lora_magnitude_vector[active_adapter].get_weight_norm(base_layer.weight, transpose(delta_weight, self.fan_in_fan_out), scaling=1).detach()
+                        self._cache_store(f'{active_adapter}-weight_norm', weight_norm)
+                        dora_factor = self.lora_magnitude_vector[active_adapter].weight / weight_norm
+                        dora_factor = transpose(dora_factor.view(-1, 1), self.fan_in_fan_out)
+                        new_weight = dora_factor * (base_layer.weight.data + delta_weight)
+                        base_layer.weight.data = new_weight
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        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():
+                weight = self.get_base_layer().weight
+                delta_weight = self.get_delta_weight(active_adapter)
+                if not self.use_dora[active_adapter]:
+                    weight.data -= delta_weight
+                else:
+                    weight_norm = self._cache_pop(f'{active_adapter}-weight_norm')
+                    dora_factor = self.lora_magnitude_vector[active_adapter].weight / weight_norm
+                    weight_orig = weight.data / dora_factor.view(-1, 1) - delta_weight
+                    weight.data = weight_orig
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        device = self.lora_B[adapter].weight.device
+        dtype = self.lora_B[adapter].weight.dtype
+        cast_to_fp32 = device.type == 'cpu' and (dtype == torch.float16 or dtype == torch.bfloat16)
+        weight_A = self.lora_A[adapter].weight
+        weight_B = self.lora_B[adapter].weight
+        if cast_to_fp32:
+            weight_A = weight_A.float()
+            weight_B = weight_B.float()
+        output_tensor = transpose(weight_B @ weight_A, self.fan_in_fan_out) * self.scaling[adapter]
+        if cast_to_fp32:
+            output_tensor = output_tensor.to(dtype=dtype)
+            self.lora_A[adapter].weight.data = weight_A.to(dtype)
+            self.lora_B[adapter].weight.data = weight_B.to(dtype)
+        return output_tensor
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return 'lora.' + rep
+
+def dispatch_megatron(target: torch.nn.Module, adapter_name: str, lora_config, **kwargs: Any) -> Optional[torch.nn.Module]:
+    new_module = None
+    if isinstance(target, BaseTunerLayer):
+        target_base_layer = target.get_base_layer()
+    else:
+        target_base_layer = target
+    if lora_config.megatron_config:
+        megatron_core = importlib.import_module(lora_config.megatron_core)
+    else:
+        megatron_core = None
+    if megatron_core and isinstance(target_base_layer, (megatron_core.tensor_parallel.ColumnParallelLinear, megatron_core.tensor_parallel.RowParallelLinear)):
+        megatron_kwargs = kwargs.copy()
+        megatron_config = lora_config.megatron_config
+        if isinstance(megatron_config, dict):
+            transformer_config_class = megatron_core.transformer.transformer_config.TransformerConfig
+            megatron_config = transformer_config_class(**lora_config.megatron_config)
+        megatron_kwargs['megatron_config'] = megatron_config
+        if megatron_kwargs['fan_in_fan_out']:
+            warnings.warn('fan_in_fan_out is set to True but the target module is `ColumnParallelLinear` or `RowParallelLinear`. Setting fan_in_fan_out to False.')
+            megatron_kwargs['fan_in_fan_out'] = lora_config.fan_in_fan_out = False
+        new_module = LoraParallelLinear(base_layer=target, adapter_name=adapter_name, backend=megatron_core.tensor_parallel, **megatron_kwargs)
+    return new_module
+
+# File: peft-main/src/peft/tuners/lycoris_utils.py
+from __future__ import annotations
+import warnings
+from abc import abstractmethod
+from dataclasses import dataclass, field
+from typing import Any, Optional, Union
+import torch
+import torch.nn as nn
+from tqdm import tqdm
+from peft.config import PeftConfig
+from peft.utils import ModulesToSaveWrapper, _get_submodules
+from .tuners_utils import BaseTuner, BaseTunerLayer, check_adapters_to_merge, check_target_module_exists
+
+@dataclass
+class LycorisConfig(PeftConfig):
+    rank_pattern: Optional[dict] = field(default_factory=dict, metadata={'help': 'The mapping from layer names or regexp expression to ranks which are different from the default rank specified by `r`. For example, `{model.decoder.layers.0.encoder_attn.k_proj: 8`}'})
+    alpha_pattern: Optional[dict] = field(default_factory=dict, metadata={'help': 'The mapping from layer names or regexp expression to alphas which are different from the default alpha specified by `alpha`. For example, `{model.decoder.layers.0.encoder_attn.k_proj: 32`}'})
+
+class LycorisLayer(BaseTunerLayer):
+    other_param_names = ('r', 'alpha', 'scaling', 'rank_dropout', 'module_dropout')
+
+    def __init__(self, base_layer: nn.Module) -> None:
+        self.base_layer = base_layer
+        self.r = {}
+        self.alpha = {}
+        self.scaling = {}
+        self.rank_dropout = {}
+        self.module_dropout = {}
+        self._disable_adapters = False
+        self.merged_adapters = []
+
+    @property
+    @abstractmethod
+    def _available_adapters(self) -> set[str]:
+        ...
+
+    def _init_empty_weights(self, cls, *args, **kwargs) -> None:
+        kwargs = kwargs.copy()
+        final_device = kwargs.pop('device', 'cpu')
+        cls.__init__(self, *args, device='meta', **kwargs)
+        self.to_empty(device=final_device)
+
+    @abstractmethod
+    def create_adapter_parameters(self, adapter_name: str, r: int, **kwargs):
+        ...
+
+    @abstractmethod
+    def _get_delta_activations(self, adapter_name: str, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+
+    @abstractmethod
+    def get_delta_weight(self, adapter_name: str) -> torch.Tensor:
+        ...
+
+    def merge(self, safe_merge: bool=False, adapter_names: Optional[list[str]]=None) -> None:
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            return
+        for active_adapter in adapter_names:
+            if active_adapter in self._available_adapters:
+                base_layer = self.get_base_layer()
+                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)
+
+    @abstractmethod
+    def reset_adapter_parameters(self, adapter_name: str):
+        ...
+
+    def set_scale(self, adapter, scale):
+        if adapter not in self._available_adapters:
+            return
+        self.scaling[adapter] = scale * self.alpha[adapter] / self.r[adapter]
+
+    def scale_layer(self, scale: float) -> None:
+        if scale == 1:
+            return
+        for active_adapter in self.active_adapters:
+            if active_adapter not in self._available_adapters:
+                continue
+            self.scaling[active_adapter] *= scale
+
+    def unmerge(self) -> None:
+        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._available_adapters:
+                self.get_base_layer().weight.data -= self.get_delta_weight(active_adapter)
+
+    def unscale_layer(self, scale=None) -> None:
+        for active_adapter in self.active_adapters:
+            if active_adapter not in self._available_adapters:
+                continue
+            if scale is None:
+                self.scaling[active_adapter] = self.alpha[active_adapter] / self.r[active_adapter]
+            else:
+                self.scaling[active_adapter] /= scale
+
+    @abstractmethod
+    def update_layer(self, adapter_name: str, r: int, alpha: float, **kwargs):
+        ...
+
+class LycorisTuner(BaseTuner):
+    prefix: str
+    layers_mapping: dict[type[torch.nn.Module], type[LycorisLayer]]
+
+    def __init__(self, model, config, adapter_name):
+        super().__init__(model, config, adapter_name)
+
+    def __getattr__(self, name: str):
+        try:
+            return super().__getattr__(name)
+        except AttributeError:
+            if name == 'model':
+                raise
+            return getattr(self.model, name)
+
+    @staticmethod
+    def _check_target_module_exists(config, key):
+        return check_target_module_exists(config, key)
+
+    @abstractmethod
+    def _create_and_replace(self, config: LycorisConfig, adapter_name: str, target: Union[LycorisLayer, nn.Module], target_name, parent, current_key):
+        ...
+
+    @classmethod
+    def _create_new_module(cls, config: LycorisConfig, adapter_name: str, target: nn.Module, **kwargs) -> LycorisLayer:
+        new_module_cls = None
+        for (subtype, target_cls) in cls.layers_mapping.items():
+            if hasattr(target, 'base_layer') and isinstance(target.get_base_layer(), subtype) and isinstance(target, BaseTunerLayer):
+                new_module_cls = target_cls
+                break
+            elif isinstance(target, subtype):
+                new_module_cls = target_cls
+                break
+        if new_module_cls is None:
+            supported_modules = ', '.join((layer.__name__ for layer in cls.layers_mapping.keys()))
+            raise ValueError(f'Target module of type {type(target)} not supported, currently only adapters for {supported_modules} are supported')
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+        if isinstance(target_base_layer, torch.nn.Conv2d):
+            new_module = new_module_cls(target, adapter_name=adapter_name, **kwargs)
+        elif isinstance(target_base_layer, torch.nn.Linear):
+            new_module = new_module_cls(target, adapter_name=adapter_name, **kwargs)
+        else:
+            supported_modules = ', '.join((layer.__name__ for layer in cls.layers_mapping.keys()))
+            raise ValueError(f'Target module of type {type(target)} not supported, currently only adapters for {supported_modules} are supported')
+        return new_module
+
+    def _mark_only_adapters_as_trainable(self, model: nn.Module) -> None:
+        for (n, p) in model.named_parameters():
+            if self.prefix not in n:
+                p.requires_grad = False
+
+    @staticmethod
+    def _prepare_adapter_config(peft_config, model_config):
+        if peft_config.target_modules is None:
+            raise ValueError('Please specify `target_modules` in `peft_config`')
+        return peft_config
+
+    def _replace_module(self, parent, child_name, new_module, child):
+        setattr(parent, child_name, new_module)
+        if not hasattr(new_module, 'base_layer'):
+            new_module.weight = child.weight
+            if hasattr(child, 'bias'):
+                new_module.bias = child.bias
+        if getattr(child, 'state', None) is not None:
+            if hasattr(new_module, 'base_layer'):
+                new_module.base_layer.state = child.state
+            else:
+                new_module.state = child.state
+            new_module.to(child.weight.device)
+        for (name, module) in new_module.named_modules():
+            if self.prefix in name:
+                module.to(child.weight.device)
+
+    def _set_adapter_layers(self, enabled=True):
+        for module in self.model.modules():
+            if isinstance(module, (BaseTunerLayer, ModulesToSaveWrapper)):
+                module.enable_adapters(enabled)
+
+    def _unload_and_optionally_merge(self, merge: bool=True, progressbar: bool=False, safe_merge: bool=False, adapter_names: Optional[list[str]]=None):
+        if merge:
+            if getattr(self.model, 'quantization_method', None) == 'gptq':
+                raise ValueError('Cannot merge LOHA layers when the model is gptq quantized')
+        self._unloading_checks(adapter_names)
+        key_list = [key for (key, _) in self.model.named_modules() if self.prefix not in key]
+        desc = 'Unloading ' + ('and merging ' if merge else '') + 'model'
+        for key in tqdm(key_list, disable=not progressbar, desc=desc):
+            try:
+                (parent, target, target_name) = _get_submodules(self.model, key)
+            except AttributeError:
+                continue
+            if hasattr(target, 'base_layer'):
+                if merge:
+                    target.merge(safe_merge=safe_merge, adapter_names=adapter_names)
+                self._replace_module(parent, target_name, target.get_base_layer(), target)
+            elif isinstance(target, ModulesToSaveWrapper):
+                new_module = target.modules_to_save[target.active_adapter]
+                if hasattr(new_module, 'base_layer'):
+                    if merge:
+                        new_module.merge(safe_merge=safe_merge, adapter_names=adapter_names)
+                    new_module = new_module.get_base_layer()
+                setattr(parent, target_name, new_module)
+        return self.model
+
+    def enable_adapter_layers(self) -> None:
+        self._set_adapter_layers(enabled=True)
+
+    def disable_adapter_layers(self) -> None:
+        self._set_adapter_layers(enabled=False)
+
+    def merge_and_unload(self, progressbar: bool=False, safe_merge: bool=False, adapter_names: Optional[list[str]]=None) -> torch.nn.Module:
+        return self._unload_and_optionally_merge(progressbar=progressbar, safe_merge=safe_merge, adapter_names=adapter_names)
+
+    def unload(self) -> torch.nn.Module:
+        return self._unload_and_optionally_merge(merge=False)
+
+    def set_adapter(self, adapter_name: str | list[str]) -> None:
+        for module in self.model.modules():
+            if isinstance(module, LycorisLayer):
+                if module.merged:
+                    warnings.warn('Adapter cannot be set when the model is merged. Unmerging the model first.')
+                    module.unmerge()
+                module.set_adapter(adapter_name)
+        self.active_adapter = adapter_name
+
+    def delete_adapter(self, adapter_name: str) -> None:
+        if adapter_name not in list(self.peft_config.keys()):
+            raise ValueError(f'Adapter {adapter_name} does not exist')
+        del self.peft_config[adapter_name]
+        key_list = [key for (key, _) in self.model.named_modules() if self.prefix not in key]
+        new_adapter = None
+        for key in key_list:
+            (_, target, _) = _get_submodules(self.model, key)
+            if isinstance(target, LycorisLayer):
+                target.delete_adapter(adapter_name)
+                if new_adapter is None:
+                    new_adapter = target.active_adapters[:]
+        self.active_adapter = new_adapter or []
+
+# File: peft-main/src/peft/tuners/mixed/model.py
+from __future__ import annotations
+import warnings
+from typing import Any, Optional, Union
+from torch import nn
+from tqdm import tqdm
+from peft.tuners import adalora, loha, lokr, lora, oft
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer, check_target_module_exists
+from peft.utils import TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING, ModulesToSaveWrapper, PeftType, _get_submodules, get_auto_gptq_quant_linear
+COMPATIBLE_TUNER_TYPES = (PeftType.LORA, PeftType.LOHA, PeftType.LOKR, PeftType.ADALORA, PeftType.OFT)
+PREFIXES = [lora.LoraModel.prefix, lokr.LoKrModel.prefix, loha.LoHaModel.prefix, oft.OFTModel.prefix]
+Configs = Union[lora.LoraConfig, loha.LoHaConfig, lokr.LoKrConfig, adalora.AdaLoraConfig, oft.OFTConfig]
+Layers = (lora.layer.LoraLayer, loha.layer.LoHaLayer, lokr.layer.LoKrLayer, adalora.layer.AdaLoraLayer, oft.OFTLayer)
+
+class MixedModel(BaseTuner):
+
+    def __init__(self, model: nn.Module, config: Configs, adapter_name: str) -> None:
+        super().__init__(model, config, adapter_name)
+
+    def _check_new_adapter_config(self, config: Configs) -> None:
+        if not isinstance(config, Configs.__args__):
+            raise ValueError(f'{self.__class__.__name__} only supports {COMPATIBLE_TUNER_TYPES} configs, but got {type(config)}.')
+        biases = (getattr(config, 'bias', None) for config in self.peft_config)
+        biases = [bias for bias in biases if bias not in (None, 'none')]
+        if len(biases) > 1:
+            raise ValueError(f"{self.__class__.__name__} supports only 1 adapter with bias. When using multiple adapters, set bias to 'none' for all adapters.")
+
+    @staticmethod
+    def _check_target_module_exists(config: Configs, key: str):
+        return check_target_module_exists(config, key)
+
+    def _create_and_replace(self, config: Configs, *args: Any, **kwargs: Any) -> None:
+        if isinstance(config, adalora.AdaLoraConfig):
+            adalora.AdaLoraModel._create_and_replace(self, config, *args, **kwargs)
+        elif isinstance(config, lora.LoraConfig):
+            lora.LoraModel._create_and_replace(self, config, *args, **kwargs)
+        elif isinstance(config, loha.LoHaConfig):
+            loha.LoHaModel._create_and_replace(self, config, *args, **kwargs)
+        elif isinstance(config, lokr.LoKrConfig):
+            lokr.LoKrModel._create_and_replace(self, config, *args, **kwargs)
+        elif isinstance(config, oft.OFTConfig):
+            oft.OFTModel._create_and_replace(self, config, *args, **kwargs)
+        else:
+            raise ValueError(f'Unsupported config type {type(config)}, should be one of {COMPATIBLE_TUNER_TYPES}.')
+
+    def _replace_module(self, parent, child_name, new_module, child) -> None:
+        setattr(parent, child_name, new_module)
+        if hasattr(child, 'base_layer'):
+            child = child.get_base_layer()
+        elif hasattr(child, 'quant_linear_module'):
+            child = child.quant_linear_module
+        if not hasattr(new_module, 'base_layer'):
+            new_module.weight = child.weight
+            if hasattr(child, 'bias'):
+                new_module.bias = child.bias
+        if getattr(child, 'state', None) is not None:
+            if hasattr(new_module, 'base_layer'):
+                new_module.base_layer.state = child.state
+            else:
+                new_module.state = child.state
+            new_module.to(child.weight.device)
+        for (name, module) in new_module.named_modules():
+            if any((prefix in name for prefix in PREFIXES)):
+                module.to(child.weight.device)
+            if 'ranknum' in name:
+                module.to(child.weight.device)
+
+    def _mark_only_adapters_as_trainable(self, model: nn.Module) -> None:
+        for (n, p) in model.named_parameters():
+            if not any((prefix in n for prefix in PREFIXES)):
+                p.requires_grad = False
+        for active_adapter in self.active_adapters:
+            bias = getattr(self.peft_config[active_adapter], 'bias', 'none')
+            if bias == 'none':
+                continue
+            if bias == 'all':
+                for (n, p) in model.named_parameters():
+                    if 'bias' in n:
+                        p.requires_grad = True
+            elif bias == 'lora_only':
+                for m in model.modules():
+                    if isinstance(m, Layers) and hasattr(m, 'bias') and (m.bias is not None):
+                        m.bias.requires_grad = True
+            else:
+                raise ValueError(f'Requested bias: {bias}, is not implemented.')
+
+    @staticmethod
+    def _create_new_module(config, adapter_name, target, **kwargs):
+        gptq_quantization_config = kwargs.get('gptq_quantization_config', None)
+        AutoGPTQQuantLinear = get_auto_gptq_quant_linear(gptq_quantization_config)
+        if gptq_quantization_config is not None or AutoGPTQQuantLinear is not None:
+            raise ValueError(f'GPTQ quantization not supported for {config.peft_type.value} (yet).')
+        loaded_in_8bit = kwargs.pop('loaded_in_8bit', False)
+        loaded_in_4bit = kwargs.pop('loaded_in_4bit', False)
+        if loaded_in_8bit or loaded_in_4bit:
+            raise ValueError(f'8bit and 4bit quantization not supported for {config.peft_type.value} (yet).')
+        if isinstance(config, adalora.AdaLoraConfig):
+            new_module = adalora.AdaLoraModel._create_new_module(config, adapter_name, target, **kwargs)
+        elif isinstance(config, lora.LoraConfig):
+            new_module = lora.LoraModel._create_new_module(config, adapter_name, target, **kwargs)
+        elif isinstance(config, loha.LoHaConfig):
+            new_module = loha.LoHaModel._create_new_module(config, adapter_name, target, **kwargs)
+        elif isinstance(config, lokr.LoKrConfig):
+            new_module = lokr.LoKrModel._create_new_module(config, adapter_name, target, **kwargs)
+        elif isinstance(config, oft.OFTConfig):
+            new_module = oft.OFTModel._create_new_module(config, adapter_name, target, **kwargs)
+        else:
+            raise ValueError(f'Unknown config type {type(config)}, should be one of {COMPATIBLE_TUNER_TYPES}.')
+        return new_module
+
+    def __getattr__(self, name: str):
+        try:
+            return super().__getattr__(name)
+        except AttributeError:
+            if name == 'model':
+                raise
+            return getattr(self.model, name)
+
+    def _set_adapter_layers(self, enabled=True):
+        for module in self.model.modules():
+            if isinstance(module, (BaseTunerLayer, ModulesToSaveWrapper)):
+                module.enable_adapters(enabled)
+
+    def enable_adapter_layers(self):
+        self._set_adapter_layers(enabled=True)
+
+    def disable_adapter_layers(self):
+        for active_adapter in self.active_adapters:
+            val = getattr(self.peft_config[active_adapter], 'bias', 'none')
+            if val != 'none':
+                msg = f"Careful, disabling adapter layers with bias configured to be '{val}' does not produce the same output as the the base model would without adaption."
+                warnings.warn(msg)
+        self._set_adapter_layers(enabled=False)
+
+    def set_adapter(self, adapter_name: Union[str, list[str]]) -> None:
+        for module in self.model.modules():
+            if isinstance(module, Layers):
+                if module.merged:
+                    warnings.warn('Adapter cannot be set when the model is merged. Unmerging the model first.')
+                    module.unmerge()
+                module.set_adapter(adapter_name)
+        self.active_adapter = adapter_name
+
+    @staticmethod
+    def _prepare_adapter_config(peft_config, model_config):
+        if peft_config.target_modules is None:
+            if model_config['model_type'] not in TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING:
+                raise ValueError('Please specify `target_modules` in `peft_config`')
+            peft_config.target_modules = set(TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING[model_config['model_type']])
+        return peft_config
+
+    def _unload_and_optionally_merge(self, merge=True, progressbar: bool=False, safe_merge: bool=False, adapter_names: Optional[list[str]]=None):
+        if merge:
+            if getattr(self.model, 'quantization_method', None) == 'gptq':
+                raise ValueError('Cannot merge layers when the model is gptq quantized')
+
+        def merge_recursively(module):
+            path = []
+            layer = module
+            while hasattr(layer, 'base_layer'):
+                path.append(layer)
+                layer = layer.base_layer
+            for (layer_before, layer_after) in zip(path[:-1], path[1:]):
+                layer_after.merge(safe_merge=safe_merge, adapter_names=adapter_names)
+                layer_before.base_layer = layer_after.base_layer
+            module.merge(safe_merge=safe_merge, adapter_names=adapter_names)
+        key_list = [key for (key, _) in self.model.named_modules() if not any((prefix in key for prefix in PREFIXES))]
+        desc = 'Unloading ' + ('and merging ' if merge else '') + 'model'
+        for key in tqdm(key_list, disable=not progressbar, desc=desc):
+            try:
+                (parent, target, target_name) = _get_submodules(self.model, key)
+            except AttributeError:
+                continue
+            if hasattr(target, 'base_layer'):
+                if merge:
+                    merge_recursively(target)
+                self._replace_module(parent, target_name, target.get_base_layer(), target)
+            elif isinstance(target, ModulesToSaveWrapper):
+                new_module = target.modules_to_save[target.active_adapter]
+                if hasattr(new_module, 'base_layer'):
+                    if merge:
+                        new_module.merge(safe_merge=safe_merge, adapter_names=adapter_names)
+                    new_module = new_module.get_base_layer()
+                setattr(parent, target_name, new_module)
+        return self.model
+
+    def add_weighted_adapter(self, *args: Any, **kwargs: Any) -> None:
+        raise NotImplementedError(f'Weighted adapters are not supported for {self.__class__.__name__} (yet).')
+
+    def delete_adapter(self, adapter_name: Union[str, list[str]]) -> None:
+        if isinstance(adapter_name, str):
+            adapter_names = [adapter_name]
+        else:
+            adapter_names = adapter_name
+        mismatched = set(adapter_names) - set(self.peft_config.keys())
+        if mismatched:
+            raise ValueError(f'Adapter(s) {sorted(mismatched)} not found, available adapters: {sorted(self.peft_config.keys())}')
+        for adapter_name in adapter_names:
+            del self.peft_config[adapter_name]
+            key_list = [key for (key, _) in self.model.named_modules() if not any((prefix in key for prefix in PREFIXES))]
+            new_adapter = None
+            for key in key_list:
+                (_, target, _) = _get_submodules(self.model, key)
+                if isinstance(target, BaseTunerLayer):
+                    target.delete_adapter(adapter_name)
+                    if new_adapter is None:
+                        new_adapter = target.active_adapters[:]
+        self.active_adapter = new_adapter or []
+
+    def merge_and_unload(self, progressbar: bool=False, safe_merge: bool=False, adapter_names: Optional[list[str]]=None) -> nn.Module:
+        return self._unload_and_optionally_merge(progressbar=progressbar, safe_merge=safe_merge, adapter_names=adapter_names)
+
+    def unload(self) -> nn.Module:
+        return self._unload_and_optionally_merge(merge=False)
+
+    def generate(self, *args: Any, **kwargs: Any):
+        return self.model.generate(*args, **kwargs)
+
+# File: peft-main/src/peft/tuners/multitask_prompt_tuning/config.py
+import enum
+from dataclasses import dataclass, field
+from typing import Optional, Union
+from peft.tuners.prompt_tuning import PromptTuningConfig
+from peft.utils import PeftType
+
+class MultitaskPromptTuningInit(str, enum.Enum):
+    TEXT = 'TEXT'
+    RANDOM = 'RANDOM'
+    AVERAGE_SOURCE_TASKS = 'AVERAGE_SOURCE_TASKS'
+    EXACT_SOURCE_TASK = 'EXACT_SOURCE_TASK'
+    ONLY_SOURCE_SHARED = 'ONLY_SOURCE_SHARED'
+
+@dataclass
+class MultitaskPromptTuningConfig(PromptTuningConfig):
+    prompt_tuning_init: Union[MultitaskPromptTuningInit, str] = field(default=MultitaskPromptTuningInit.RANDOM, metadata={'help': 'How to initialize the prompt tuning parameters. Can be one of TEXT, RANDOM, AVERAGE_SOURCE_TASKS, EXACT_SOURCE_TASK, ONLY_SOURCE_SHARED.'})
+    prompt_tuning_init_state_dict_path: Optional[str] = field(default=None, metadata={'help': 'The path of source state dict. This is required when training the downstream target prompt from the pretrained source prompt'})
+    prompt_tuning_init_task: Optional[int] = field(default=0, metadata={'help': 'source task id for initialization'})
+    num_ranks: Optional[int] = field(default=1, metadata={'help': 'ranks'})
+    num_tasks: Optional[int] = field(default=1, metadata={'help': 'number of tasks'})
+
+    def __post_init__(self):
+        self.peft_type = PeftType.MULTITASK_PROMPT_TUNING
+
+# File: peft-main/src/peft/tuners/multitask_prompt_tuning/model.py
+import torch
+from peft.tuners.prompt_tuning import PromptEmbedding
+from peft.utils import TaskType
+from peft.utils.save_and_load import torch_load
+from .config import MultitaskPromptTuningConfig, MultitaskPromptTuningInit
+
+class MultitaskPromptEmbedding(PromptEmbedding):
+
+    def __init__(self, config: MultitaskPromptTuningConfig, word_embeddings):
+        super().__init__(config, word_embeddings)
+        self.num_tasks = config.num_tasks
+        self.num_ranks = config.num_ranks
+        self.num_virtual_tokens = config.num_virtual_tokens
+        self.num_transformer_submodules = config.num_transformer_submodules
+        if self.num_transformer_submodules is None:
+            self.num_transformer_submodules = 2 if config.task_type == TaskType.SEQ_2_SEQ_LM else 1
+        self.token_dim = config.token_dim
+        total_virtual_tokens = self.num_virtual_tokens * self.num_transformer_submodules
+        self.prefix_task_cols = torch.nn.Parameter(torch.normal(mean=0, std=0.02, size=(self.num_tasks, total_virtual_tokens, self.num_ranks)))
+        self.prefix_task_rows = torch.nn.Parameter(torch.normal(mean=0, std=0.02, size=(self.num_tasks, self.num_ranks, self.token_dim)))
+        if config.prompt_tuning_init in [MultitaskPromptTuningInit.AVERAGE_SOURCE_TASKS, MultitaskPromptTuningInit.EXACT_SOURCE_TASK, MultitaskPromptTuningInit.ONLY_SOURCE_SHARED]:
+            if config.prompt_tuning_init_state_dict_path is None:
+                raise ValueError(f'prompt_tuning_init_state_dict_path needs to be specified with {config.prompt_tuning_init} init method')
+            if config.prompt_tuning_init_state_dict_path.endswith('.safetensors'):
+                from safetensors.torch import load_file
+                state_dict: dict = load_file(config.prompt_tuning_init_state_dict_path)
+            else:
+                state_dict: dict = torch_load(config.prompt_tuning_init_state_dict_path, map_location=word_embeddings.weight.device)
+        if config.prompt_tuning_init in [MultitaskPromptTuningInit.AVERAGE_SOURCE_TASKS, MultitaskPromptTuningInit.EXACT_SOURCE_TASK]:
+            prefix_task_cols_: torch.Tensor = state_dict['prefix_task_cols']
+            prefix_task_rows_: torch.Tensor = state_dict['prefix_task_rows']
+            if config.prompt_tuning_init == MultitaskPromptTuningInit.AVERAGE_SOURCE_TASKS:
+                prefix_task_cols_ = prefix_task_cols_.mean(0, keepdim=True)
+                prefix_task_rows_ = prefix_task_rows_.mean(0, keepdim=True)
+            elif config.prompt_tuning_init == MultitaskPromptTuningInit.EXACT_SOURCE_TASK:
+                prefix_task_cols_ = prefix_task_cols_[config.prompt_tuning_init_task, ...].unsqueeze(0)
+                prefix_task_rows_ = prefix_task_rows_[config.prompt_tuning_init_task, ...].unsqueeze(0)
+            state_dict = {'embedding.weight': state_dict['prompt_embeddings'], 'prefix_task_cols': prefix_task_cols_, 'prefix_task_rows': prefix_task_rows_}
+            self.load_state_dict(state_dict, strict=True)
+        elif config.prompt_tuning_init == MultitaskPromptTuningInit.ONLY_SOURCE_SHARED:
+            state_dict = {'embedding.weight': state_dict['prompt_embeddings']}
+            self.load_state_dict(state_dict, strict=False)
+
+    def forward(self, indices, task_ids):
+        if task_ids is None:
+            raise ValueError('task_ids cannot be None')
+        prompt_embeddings = self.embedding(indices)
+        task_cols = torch.index_select(self.prefix_task_cols, 0, task_ids)
+        task_rows = torch.index_select(self.prefix_task_rows, 0, task_ids)
+        task_prompts = torch.matmul(task_cols, task_rows)
+        prompt_embeddings *= task_prompts
+        return prompt_embeddings
+
+# File: peft-main/src/peft/tuners/oft/config.py
+from dataclasses import dataclass, field
+from typing import List, Optional, Union
+from peft.tuners.lycoris_utils import LycorisConfig
+from peft.utils import PeftType
+
+@dataclass
+class OFTConfig(LycorisConfig):
+    r: int = field(default=8, metadata={'help': 'OFT rank'})
+    module_dropout: float = field(default=0.0, metadata={'help': 'The dropout probability for disabling OFT modules during training'})
+    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 OFT.For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$' This can also be a wildcard 'all-linear' which matches all linear/Conv1D layers except the output layer."})
+    init_weights: bool = field(default=True, metadata={'help': "Whether to initialize the weights of the OFT layers with their default initialization. Don't change this setting, except if you know exactly what you're doing."})
+    layers_to_transform: Optional[Union[List[int], int]] = field(default=None, metadata={'help': 'The layer indexes to transform, is this argument is specified, PEFT will transform only the layers indexes that are specified inside this list. If a single integer is passed, PEFT will transform only the layer at this index.'})
+    layers_pattern: Optional[str] = field(default=None, metadata={'help': 'The layer pattern name, used only if `layers_to_transform` is different to None and if the layer pattern is not in the common layers pattern.'})
+    modules_to_save: Optional[List[str]] = field(default=None, metadata={'help': 'List of modules apart from OFT 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.'})
+    coft: bool = field(default=False, metadata={'help': 'Whether to use the constrained variant of OFT or not.'})
+    eps: float = field(default=6e-05, metadata={'help': 'The control strength of COFT. The freedom of rotation. Only has an effect if `coft` is set to True.'})
+    block_share: bool = field(default=False, metadata={'help': 'Whether to share the OFT parameters between blocks or not.'})
+
+    def __post_init__(self):
+        self.peft_type = PeftType.OFT
+        self.target_modules = set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+
+# File: peft-main/src/peft/tuners/oft/layer.py
+import math
+import warnings
+from typing import Any, List, Optional, Set, Tuple
+import torch
+import torch.nn as nn
+from peft.tuners.lycoris_utils import LycorisLayer, check_adapters_to_merge
+
+class OFTLayer(nn.Module, LycorisLayer):
+    adapter_layer_names = ('oft_r',)
+
+    def __init__(self, base_layer: nn.Module):
+        super().__init__()
+        LycorisLayer.__init__(self, base_layer)
+        self.oft_r = nn.ParameterDict({})
+        self.coft = {}
+        self.eps = {}
+        self.block_share = {}
+
+    @property
+    def _available_adapters(self) -> Set[str]:
+        return {*self.oft_r}
+
+    def create_adapter_parameters(self, adapter_name: str, r: int, shape: Tuple[int, ...], block_share: bool):
+        if block_share:
+            self.oft_r[adapter_name] = nn.Parameter(torch.empty(1, math.ceil(shape[0] / r), math.ceil(shape[0] / r)))
+        else:
+            self.oft_r[adapter_name] = nn.Parameter(torch.empty(r, math.ceil(shape[0] / r), math.ceil(shape[0] / r)))
+
+    def reset_adapter_parameters(self, adapter_name: str):
+        nn.init.zeros_(self.oft_r[adapter_name])
+
+    def reset_adapter_parameters_random(self, adapter_name: str):
+        nn.init.kaiming_uniform_(self.oft_r[adapter_name], a=math.sqrt(5))
+
+    def update_layer(self, adapter_name: str, r: int, module_dropout: float, init_weights: bool, coft: bool=False, eps: float=6e-05, block_share: bool=False, **kwargs) -> None:
+        if r <= 0:
+            raise ValueError(f'`r` should be a positive integer value but the value passed is {r}')
+        self.r[adapter_name] = r
+        self.module_dropout[adapter_name] = module_dropout
+        self.coft[adapter_name] = coft
+        self.block_share[adapter_name] = block_share
+        base_layer = self.get_base_layer()
+        if isinstance(base_layer, nn.Linear):
+            shape = tuple(base_layer.weight.shape)
+        elif isinstance(base_layer, nn.Conv2d):
+            shape = (base_layer.out_channels, base_layer.in_channels * base_layer.kernel_size[0] * base_layer.kernel_size[1])
+        else:
+            raise TypeError(f'OFT is not implemented for base layers of type {type(base_layer).__name__}')
+        self.eps[adapter_name] = eps * math.ceil(shape[0] / r) * math.ceil(shape[0] / r)
+        self.create_adapter_parameters(adapter_name, r, shape, block_share)
+        if init_weights:
+            self.reset_adapter_parameters(adapter_name)
+        else:
+            self.reset_adapter_parameters_random(adapter_name)
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters)
+
+    def unscale_layer(self, scale=None) -> None:
+        pass
+
+    def merge(self, safe_merge: bool=False, adapter_names: Optional[List[str]]=None) -> None:
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            return
+        for active_adapter in adapter_names:
+            if active_adapter in self._available_adapters:
+                base_layer = self.get_base_layer()
+                orig_weights = base_layer.weight.data
+                if isinstance(base_layer, nn.Linear):
+                    orig_weights = torch.transpose(orig_weights, 0, 1)
+                elif isinstance(base_layer, nn.Conv2d):
+                    orig_weights = orig_weights.view([base_layer.out_channels, base_layer.in_channels * base_layer.kernel_size[0] * base_layer.kernel_size[1]])
+                    orig_weights = torch.transpose(orig_weights, 0, 1)
+                delta_weight = self.get_delta_weight(active_adapter)
+                if orig_weights.shape[1] != delta_weight.shape[1]:
+                    delta_weight = delta_weight[:orig_weights.shape[1], :orig_weights.shape[1]]
+                new_weights = torch.mm(orig_weights, delta_weight)
+                if isinstance(base_layer, nn.Linear):
+                    new_weights = torch.transpose(new_weights, 0, 1)
+                elif isinstance(base_layer, nn.Conv2d):
+                    new_weights = torch.transpose(new_weights, 0, 1)
+                    new_weights = new_weights.view([base_layer.out_channels, base_layer.in_channels, base_layer.kernel_size[0], base_layer.kernel_size[1]])
+                if safe_merge and (not torch.isfinite(new_weights).all()):
+                    raise ValueError(f'NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken')
+                base_layer.weight.data = new_weights.contiguous()
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        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._available_adapters:
+                base_layer = self.get_base_layer()
+                new_weights = base_layer.weight.data
+                if isinstance(base_layer, nn.Linear):
+                    new_weights = torch.transpose(new_weights, 0, 1)
+                elif isinstance(base_layer, nn.Conv2d):
+                    new_weights = new_weights.view([base_layer.out_channels, base_layer.in_channels * base_layer.kernel_size[0] * base_layer.kernel_size[1]])
+                    new_weights = torch.transpose(new_weights, 0, 1)
+                delta_weight = self.get_delta_weight(active_adapter)
+                if new_weights.shape[1] != delta_weight.shape[1]:
+                    delta_weight = delta_weight[:new_weights.shape[1], :new_weights.shape[1]]
+                delta_inv = torch.inverse(delta_weight)
+                orig_weights = torch.mm(new_weights, delta_inv)
+                if isinstance(base_layer, nn.Linear):
+                    orig_weights = torch.transpose(orig_weights, 0, 1)
+                elif isinstance(base_layer, nn.Conv2d):
+                    orig_weights = torch.transpose(orig_weights, 0, 1)
+                    orig_weights = orig_weights.reshape([base_layer.out_channels, base_layer.in_channels, base_layer.kernel_size[0], base_layer.kernel_size[1]])
+                base_layer.weight.data = orig_weights.contiguous()
+
+    def get_delta_weight(self, adapter_name: str) -> torch.Tensor:
+        rank = self.r[adapter_name]
+        coft = self.coft[adapter_name]
+        eps = self.eps[adapter_name]
+        opt_r = self.oft_r[adapter_name]
+        if coft:
+            with torch.no_grad():
+                opt_r.copy_(self._project_batch(opt_r, eps=eps))
+        orth_rotate = self._cayley_batch(opt_r)
+        weight = self._block_diagonal(orth_rotate, rank)
+        return weight
+
+    def _cayley_batch(self, data: torch.Tensor) -> torch.Tensor:
+        (b, r, c) = data.shape
+        skew = 0.5 * (data - data.transpose(1, 2))
+        I = torch.eye(r, device=data.device).unsqueeze(0).expand(b, r, c)
+        Q = torch.bmm(I - skew, torch.inverse(I + skew))
+        return Q
+
+    def _block_diagonal(self, oft_r: torch.Tensor, rank: int) -> torch.Tensor:
+        if oft_r.shape[0] == 1:
+            blocks = [oft_r[0, ...] for i in range(rank)]
+        else:
+            blocks = [oft_r[i, ...] for i in range(rank)]
+        A = torch.block_diag(*blocks)
+        return A
+
+    def _project_batch(self, oft_r, eps=1e-05):
+        eps = eps * 1 / torch.sqrt(torch.tensor(oft_r.shape[0]))
+        I = torch.zeros((oft_r.size(1), oft_r.size(1)), device=oft_r.device, dtype=oft_r.dtype).unsqueeze(0).expand_as(oft_r)
+        diff = oft_r - I
+        norm_diff = torch.norm(oft_r - I, dim=(1, 2), keepdim=True)
+        mask = (norm_diff <= eps).bool()
+        out = torch.where(mask, oft_r, I + eps * (diff / norm_diff))
+        return out
+
+    def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+        previous_dtype = x.dtype
+        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)
+            if len(result.shape) == 4:
+                result = result.permute(0, 2, 3, 1)
+            base_layer = self.get_base_layer()
+            base_bias = base_layer.bias
+            if base_bias is not None:
+                result = result - base_bias.data
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self._available_adapters:
+                    continue
+                module_dropout = self.module_dropout[active_adapter]
+                if not self.training or (self.training and torch.rand(1) > module_dropout):
+                    result = self._get_delta_activations(active_adapter, result, *args, **kwargs)
+            if base_bias is not None:
+                result = result + base_bias.data
+            if len(result.shape) == 4:
+                result = result.permute(0, 3, 1, 2)
+        result = result.to(previous_dtype)
+        return result
+
+class Linear(OFTLayer):
+
+    def __init__(self, base_layer: nn.Module, adapter_name: str='default', r: int=0, module_dropout: float=0.0, init_weights: bool=True, **kwargs):
+        super().__init__(base_layer)
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, module_dropout, init_weights, **kwargs)
+
+    def _get_delta_activations(self, adapter_name: str, input: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        delta_weight = self.get_delta_weight(adapter_name)
+        base_layer = self.get_base_layer()
+        base_weight = base_layer.weight.data
+        delta_weight = delta_weight[:base_weight.shape[0], :base_weight.shape[0]]
+        return torch.matmul(input, delta_weight)
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return 'oft.' + rep
+
+class Conv2d(OFTLayer):
+
+    def __init__(self, base_layer: nn.Module, adapter_name: str='default', r: int=0, module_dropout: float=0.0, init_weights: bool=True, **kwargs):
+        super().__init__(base_layer)
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, module_dropout, init_weights, **kwargs)
+
+    def _get_delta_activations(self, adapter_name: str, input: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        delta_weight = self.get_delta_weight(adapter_name)
+        base_layer = self.get_base_layer()
+        base_weight = base_layer.weight.data
+        delta_weight = delta_weight[:base_weight.shape[0], :base_weight.shape[0]]
+        return torch.matmul(input, delta_weight)
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return 'oft.' + rep
+
+# File: peft-main/src/peft/tuners/oft/model.py
+import re
+from typing import Dict, Type, Union
+import torch
+from torch import nn
+from peft.tuners.lycoris_utils import LycorisConfig, LycorisTuner
+from .layer import Conv2d, Linear, OFTLayer
+
+class OFTModel(LycorisTuner):
+    prefix: str = 'oft_'
+    layers_mapping: Dict[Type[torch.nn.Module], Type[OFTLayer]] = {torch.nn.Conv2d: Conv2d, torch.nn.Linear: Linear}
+
+    def _create_and_replace(self, config: LycorisConfig, adapter_name: str, target: Union[OFTLayer, nn.Module], target_name: str, parent: nn.Module, current_key: str) -> None:
+        pattern_keys = list(config.rank_pattern.keys())
+        target_name_key = next(filter(lambda key: re.match(f'(.*\\.)?{key}$', current_key), pattern_keys), target_name)
+        kwargs = config.to_dict()
+        kwargs['r'] = config.rank_pattern.get(target_name_key, config.r)
+        if isinstance(target, OFTLayer):
+            target.update_layer(adapter_name, **kwargs)
+        else:
+            new_module = self._create_new_module(config, adapter_name, target, **kwargs)
+            self._replace_module(parent, target_name, new_module, target)
+
+# File: peft-main/src/peft/tuners/p_tuning/config.py
+import enum
+from dataclasses import dataclass, field
+from typing import Union
+from peft.config import PromptLearningConfig
+from peft.utils import PeftType
+
+class PromptEncoderReparameterizationType(str, enum.Enum):
+    MLP = 'MLP'
+    LSTM = 'LSTM'
+
+@dataclass
+class PromptEncoderConfig(PromptLearningConfig):
+    encoder_reparameterization_type: Union[str, PromptEncoderReparameterizationType] = field(default=PromptEncoderReparameterizationType.MLP, metadata={'help': 'How to reparameterize the prompt encoder'})
+    encoder_hidden_size: int = field(default=None, metadata={'help': 'The hidden size of the prompt encoder'})
+    encoder_num_layers: int = field(default=2, metadata={'help': 'The number of layers of the prompt encoder'})
+    encoder_dropout: float = field(default=0.0, metadata={'help': 'The dropout of the prompt encoder'})
+
+    def __post_init__(self):
+        self.peft_type = PeftType.P_TUNING
+
+# File: peft-main/src/peft/tuners/p_tuning/model.py
+import warnings
+import torch
+from .config import PromptEncoderConfig, PromptEncoderReparameterizationType
+
+class PromptEncoder(torch.nn.Module):
+
+    def __init__(self, config):
+        super().__init__()
+        self.token_dim = config.token_dim
+        self.input_size = self.token_dim
+        self.output_size = self.token_dim
+        self.hidden_size = config.encoder_hidden_size
+        self.total_virtual_tokens = config.num_virtual_tokens * config.num_transformer_submodules
+        self.encoder_type = config.encoder_reparameterization_type
+        self.embedding = torch.nn.Embedding(self.total_virtual_tokens, self.token_dim)
+        if not config.inference_mode:
+            if self.encoder_type == PromptEncoderReparameterizationType.LSTM:
+                lstm_dropout = config.encoder_dropout
+                num_layers = config.encoder_num_layers
+                self.lstm_head = torch.nn.LSTM(input_size=self.input_size, hidden_size=self.hidden_size, num_layers=num_layers, dropout=lstm_dropout, bidirectional=True, batch_first=True)
+                self.mlp_head = torch.nn.Sequential(torch.nn.Linear(self.hidden_size * 2, self.hidden_size * 2), torch.nn.ReLU(), torch.nn.Linear(self.hidden_size * 2, self.output_size))
+            elif self.encoder_type == PromptEncoderReparameterizationType.MLP:
+                encoder_num_layers_default = PromptEncoderConfig.encoder_num_layers
+                if config.encoder_num_layers != encoder_num_layers_default:
+                    warnings.warn(f'for {self.encoder_type.value}, the argument `encoder_num_layers` is ignored. Exactly {encoder_num_layers_default} MLP layers are used.')
+                layers = [torch.nn.Linear(self.input_size, self.hidden_size), torch.nn.ReLU(), torch.nn.Linear(self.hidden_size, self.hidden_size), torch.nn.ReLU(), torch.nn.Linear(self.hidden_size, self.output_size)]
+                self.mlp_head = torch.nn.Sequential(*layers)
+            else:
+                raise ValueError('Prompt encoder type not recognized. Please use one of MLP (recommended) or LSTM.')
+
+    def forward(self, indices):
+        input_embeds = self.embedding(indices)
+        if self.encoder_type == PromptEncoderReparameterizationType.LSTM:
+            output_embeds = self.mlp_head(self.lstm_head(input_embeds)[0])
+        elif self.encoder_type == PromptEncoderReparameterizationType.MLP:
+            output_embeds = self.mlp_head(input_embeds)
+        else:
+            raise ValueError('Prompt encoder type not recognized. Please use one of MLP (recommended) or LSTM.')
+        return output_embeds
+
+# File: peft-main/src/peft/tuners/poly/config.py
+from dataclasses import dataclass, field
+from typing import List, Literal, Optional, Union
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+@dataclass
+class PolyConfig(PeftConfig):
+    r: int = field(default=8, metadata={'help': 'Lora attention dimension'})
+    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 Poly.For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$' "})
+    modules_to_save: Optional[List[str]] = field(default=None, metadata={'help': 'List of modules apart from Poly 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 weights of the Poly layers with their default initialization. Don't change this setting, except if you know exactly what you're doing."})
+    poly_type: Literal['poly'] = field(default='poly', metadata={'help': 'Type of Poly modules to be used. Currently only "poly" is supported.'})
+    n_tasks: int = field(default=1, metadata={'help': 'Number of tasks in multitasking scenario.'})
+    n_skills: int = field(default=4, metadata={'help': 'Number of skills (LoRA) in each Poly layer.'})
+    n_splits: int = field(default=1, metadata={'help': 'Number of splits within each LoRA of a Poly layer.'})
+
+    def __post_init__(self):
+        self.peft_type = PeftType.POLY
+        self.target_modules = set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+
+# File: peft-main/src/peft/tuners/poly/layer.py
+import math
+from typing import Any
+import torch
+import torch.nn as nn
+from peft.tuners.tuners_utils import BaseTunerLayer
+from .config import PolyConfig
+from .router import get_router
+
+class PolyLayer(BaseTunerLayer):
+    adapter_layer_names = ('poly_lora_A', 'poly_lora_B', 'poly_router')
+    other_param_names = ('r', 'n_tasks', 'n_skills', 'n_splits')
+
+    def __init__(self, base_layer: nn.Module, **kwargs):
+        self.base_layer = base_layer
+        self.r = {}
+        self.n_tasks = {}
+        self.n_skills = {}
+        self.n_splits = {}
+        self.poly_type = {}
+        self.poly_router = nn.ModuleDict()
+        self.poly_lora_A = nn.ParameterDict()
+        self.poly_lora_B = nn.ParameterDict()
+        self.kwargs = kwargs
+        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 ValueError(f'Unsupported layer type {type(base_layer)}')
+        self.in_features = in_features
+        self.out_features = out_features
+
+    def update_layer(self, adapter_name, poly_config):
+        if poly_config.r <= 0:
+            raise ValueError(f'`r` should be a positive integer value but the value passed is {poly_config.r}')
+        self.r[adapter_name] = poly_config.r
+        self.n_tasks[adapter_name] = poly_config.n_tasks
+        self.n_skills[adapter_name] = poly_config.n_skills
+        self.n_splits[adapter_name] = poly_config.n_splits
+        self.poly_type[adapter_name] = poly_config.poly_type
+        self.poly_lora_A[adapter_name] = nn.Parameter(torch.empty(poly_config.n_splits, poly_config.n_skills, self.in_features // poly_config.n_splits, poly_config.r))
+        self.poly_lora_B[adapter_name] = nn.Parameter(torch.empty(poly_config.n_splits, poly_config.n_skills, poly_config.r, self.out_features // poly_config.n_splits))
+        self.poly_router[adapter_name] = get_router(poly_config)
+        self.reset_poly_parameters(adapter_name, init_weights=poly_config.init_weights)
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters)
+
+    def reset_poly_parameters(self, adapter_name, init_weights):
+        if adapter_name in self.poly_lora_A.keys():
+            (n_splits, n_skills, d, r) = self.poly_lora_A[adapter_name].shape
+            for skill in range(n_skills):
+                for split in range(n_splits):
+                    param = torch.empty((r, d))
+                    torch.nn.init.kaiming_uniform_(param, a=math.sqrt(5))
+                    self.poly_lora_A[adapter_name].data[split, skill, :, :] = param.T
+            if init_weights:
+                torch.nn.init.zeros_(self.poly_lora_B[adapter_name])
+            else:
+                (n_splits, n_skills, r, d) = self.poly_lora_B[adapter_name].shape
+                for skill in range(n_skills):
+                    for split in range(n_splits):
+                        param = torch.empty((d, r))
+                        torch.nn.init.kaiming_uniform_(param, a=math.sqrt(5))
+                        self.poly_lora_B[adapter_name].data[split, skill, :, :] = param.T
+            self.poly_router[adapter_name].reset()
+
+class Linear(nn.Module, PolyLayer):
+
+    def __init__(self, base_layer, adapter_name: str, poly_config: PolyConfig, **kwargs) -> None:
+        super().__init__()
+        PolyLayer.__init__(self, base_layer, **kwargs)
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, poly_config)
+
+    def forward(self, x: torch.Tensor, *args: Any, task_ids: torch.Tensor=None, **kwargs: Any) -> torch.Tensor:
+        previous_dtype = x.dtype
+        if self.disable_adapters:
+            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.poly_lora_A.keys():
+                    continue
+                r = self.r[active_adapter]
+                poly_router = self.poly_router[active_adapter]
+                poly_lora_A = self.poly_lora_A[active_adapter]
+                poly_lora_B = self.poly_lora_B[active_adapter]
+                mixing_weights = poly_router(task_ids=task_ids, input_ids=x)
+                (bs, n_splits, n_skills) = mixing_weights.size()
+                A = torch.einsum('bqs,qsdr->bqdr', (mixing_weights, poly_lora_A))
+                B = torch.einsum('bqs,qsrd->bqrd', (mixing_weights, poly_lora_B))
+                A = A.reshape(bs, self.in_features, r)
+                B = B.transpose(1, 2).reshape(bs, r, self.out_features)
+                x = x.to(A.dtype)
+                result += x.bmm(A).bmm(B) / r
+        result = result.to(previous_dtype)
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return 'poly.' + rep
+
+# File: peft-main/src/peft/tuners/poly/model.py
+from contextlib import contextmanager
+from dataclasses import asdict
+from enum import Enum
+from typing import Any
+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_LORA_TARGET_MODULES_MAPPING, ModulesToSaveWrapper
+from .config import PolyConfig
+from .layer import Linear, PolyLayer
+
+class PolyModel(BaseTuner):
+    prefix: str = 'poly_'
+
+    def __init__(self, model, config, adapter_name) -> None:
+        super().__init__(model, config, adapter_name)
+
+    @staticmethod
+    def _check_target_module_exists(poly_config, key):
+        return check_target_module_exists(poly_config, key)
+
+    def _create_and_replace(self, poly_config: PolyConfig, adapter_name: str, target: nn.Module, target_name: str, parent: nn.Module, **optional_kwargs: Any):
+        if isinstance(target, PolyLayer):
+            target.update_layer(adapter_name, poly_config)
+        else:
+            new_module = self._create_new_module(poly_config, adapter_name, target)
+            if adapter_name not in self.active_adapters:
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+
+    def _replace_module(self, parent, child_name, new_module, child):
+        setattr(parent, child_name, new_module)
+        if hasattr(child, 'base_layer'):
+            child = child.base_layer
+        if not hasattr(new_module, 'base_layer'):
+            new_module.weight = child.weight
+            if hasattr(child, 'bias'):
+                new_module.bias = child.bias
+        if getattr(child, 'state', None) is not None:
+            if hasattr(new_module, 'base_layer'):
+                new_module.base_layer.state = child.state
+            else:
+                new_module.state = child.state
+            new_module.to(child.weight.device)
+        for (name, module) in new_module.named_modules():
+            if self.prefix in name or 'ranknum' in name:
+                weight = child.qweight if hasattr(child, 'qweight') else child.weight
+                module.to(weight.device)
+
+    def _mark_only_adapters_as_trainable(self, model: nn.Module) -> None:
+        for (n, p) in model.named_parameters():
+            if self.prefix not in n:
+                p.requires_grad = False
+
+    @staticmethod
+    def _create_new_module(poly_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):
+            return Linear(target, adapter_name, poly_config, **kwargs)
+        else:
+            raise ValueError(f'Target module {target} is not supported. Currently, only the following modules are supported: `torch.nn.Linear`.')
+
+    def __getattr__(self, name: str):
+        try:
+            return super().__getattr__(name)
+        except AttributeError:
+            if name == 'model':
+                raise
+            return getattr(self.model, name)
+
+    def get_peft_config_as_dict(self, inference: bool=False):
+        config_dict = {}
+        for (key, value) in self.peft_config.items():
+            config = {k: v.value if isinstance(v, Enum) else v for (k, v) in asdict(value).items()}
+            if inference:
+                config['inference_mode'] = True
+        config_dict[key] = config
+        return config
+
+    def _set_adapter_layers(self, enabled=True):
+        for module in self.model.modules():
+            if isinstance(module, (PolyLayer, ModulesToSaveWrapper)):
+                module.enable_adapters(enabled)
+
+    def enable_adapter_layers(self):
+        self._set_adapter_layers(enabled=True)
+
+    def disable_adapter_layers(self):
+        self._set_adapter_layers(enabled=False)
+
+    def set_adapter(self, adapter_name):
+        for module in self.model.modules():
+            if isinstance(module, PolyLayer):
+                module.set_adapter(adapter_name)
+
+    def _prepare_adapter_config(self, peft_config, model_config):
+        if peft_config.target_modules is None:
+            if model_config['model_type'] not in TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING:
+                raise ValueError('Please specify `target_modules` in `peft_config`')
+            peft_config.target_modules = set(TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING[model_config['model_type']])
+        return peft_config
+
+    def _register_pre_hooks(self, task_ids):
+        if task_ids is None:
+            return []
+
+        def pre_hook(_, args, kwargs):
+            kwargs['task_ids'] = task_ids
+            return (args, kwargs)
+        handles = []
+        for module in self.model.modules():
+            if isinstance(module, Linear):
+                handle = module.register_forward_pre_hook(pre_hook, with_kwargs=True)
+                handles.append(handle)
+        return handles
+
+    @contextmanager
+    def _manage_pre_hooks(self, task_ids):
+        handles = self._register_pre_hooks(task_ids)
+        try:
+            yield
+        finally:
+            for handle in handles:
+                handle.remove()
+
+    def forward(self, *args, task_ids=None, **kwargs):
+        with self._manage_pre_hooks(task_ids):
+            return self.model(*args, **kwargs)
+
+    def generate(self, *args, task_ids=None, **kwargs):
+        with self._manage_pre_hooks(task_ids):
+            return self.model.generate(*args, **kwargs)
+
+# File: peft-main/src/peft/tuners/poly/router.py
+from abc import ABC, abstractmethod
+import torch
+from torch import nn
+from torch.distributions.relaxed_bernoulli import RelaxedBernoulli
+from .config import PolyConfig
+EPS = 1e-12
+
+def get_router(poly_config: PolyConfig) -> nn.Module:
+    if poly_config.poly_type == 'poly':
+        return PolyRouter(poly_config)
+    else:
+        raise ValueError(f'Unsupported poly_type: {poly_config.poly_type}. Currently, only the following types are supported: `poly`.')
+
+class Router(nn.Module, ABC):
+
+    @abstractmethod
+    def reset(self):
+        ...
+
+    @abstractmethod
+    def forward(self, task_ids: torch.Tensor, input_ids: torch.Tensor):
+        ...
+
+class PolyRouter(Router):
+
+    def __init__(self, poly_config: PolyConfig):
+        super().__init__()
+        self.poly_type = poly_config.poly_type
+        self.n_tasks = poly_config.n_tasks
+        self.n_skills = poly_config.n_skills
+        self.n_splits = poly_config.n_splits
+        self.module_logits = nn.Parameter(torch.empty((self.n_tasks, self.n_splits * self.n_skills)))
+
+    def reset(self):
+        torch.nn.init.uniform_(self.module_logits, -0.001, 0.001)
+
+    def forward(self, task_ids: torch.Tensor, input_ids: torch.Tensor):
+        if task_ids is None:
+            raise ValueError('task_ids should not be None.')
+        if task_ids.max().item() >= self.n_tasks:
+            raise ValueError(f'Only {self.n_tasks} tasks available. Found task id = {task_ids.max().item()}')
+        task_ids = task_ids.to(self.module_logits.device)
+        module_logits = self.module_logits[task_ids]
+        module_logits = module_logits.view(-1, self.n_splits, self.n_skills)
+        if self.training:
+            module_logits = RelaxedBernoulli(temperature=1.0, logits=module_logits).rsample()
+        else:
+            module_logits = torch.sigmoid(module_logits)
+        module_weights = module_logits / (module_logits.sum(dim=-1, keepdim=True) + EPS)
+        return module_weights
+
+# File: peft-main/src/peft/tuners/prefix_tuning/config.py
+from dataclasses import dataclass, field
+from peft.config import PromptLearningConfig
+from peft.utils import PeftType
+
+@dataclass
+class PrefixTuningConfig(PromptLearningConfig):
+    encoder_hidden_size: int = field(default=None, metadata={'help': 'The hidden size of the encoder'})
+    prefix_projection: bool = field(default=False, metadata={'help': 'Whether to project the prefix tokens'})
+
+    def __post_init__(self):
+        self.peft_type = PeftType.PREFIX_TUNING
+
+# File: peft-main/src/peft/tuners/prefix_tuning/model.py
+import torch
+
+class PrefixEncoder(torch.nn.Module):
+
+    def __init__(self, config):
+        super().__init__()
+        self.prefix_projection = config.prefix_projection
+        token_dim = config.token_dim
+        num_layers = config.num_layers
+        encoder_hidden_size = config.encoder_hidden_size
+        num_virtual_tokens = config.num_virtual_tokens
+        if self.prefix_projection and (not config.inference_mode):
+            self.embedding = torch.nn.Embedding(num_virtual_tokens, token_dim)
+            self.transform = torch.nn.Sequential(torch.nn.Linear(token_dim, encoder_hidden_size), torch.nn.Tanh(), torch.nn.Linear(encoder_hidden_size, num_layers * 2 * token_dim))
+        else:
+            self.embedding = torch.nn.Embedding(num_virtual_tokens, num_layers * 2 * token_dim)
+
+    def forward(self, prefix: torch.Tensor):
+        if self.prefix_projection:
+            prefix_tokens = self.embedding(prefix)
+            past_key_values = self.transform(prefix_tokens)
+        else:
+            past_key_values = self.embedding(prefix)
+        return past_key_values
+
+# File: peft-main/src/peft/tuners/prompt_tuning/config.py
+import enum
+from dataclasses import dataclass, field
+from typing import Optional, Union
+from peft.config import PromptLearningConfig
+from peft.utils import PeftType
+
+class PromptTuningInit(str, enum.Enum):
+    TEXT = 'TEXT'
+    RANDOM = 'RANDOM'
+
+@dataclass
+class PromptTuningConfig(PromptLearningConfig):
+    prompt_tuning_init: Union[PromptTuningInit, str] = field(default=PromptTuningInit.RANDOM, metadata={'help': 'How to initialize the prompt tuning parameters'})
+    prompt_tuning_init_text: Optional[str] = field(default=None, metadata={'help': 'The text to use for prompt tuning initialization. Only used if prompt_tuning_init is `TEXT`'})
+    tokenizer_name_or_path: Optional[str] = field(default=None, metadata={'help': 'The tokenizer to use for prompt tuning initialization. Only used if prompt_tuning_init is `TEXT`'})
+    tokenizer_kwargs: Optional[dict] = field(default=None, metadata={'help': 'The keyword arguments to pass to `AutoTokenizer.from_pretrained`. Only used if prompt_tuning_init is `TEXT`'})
+
+    def __post_init__(self):
+        self.peft_type = PeftType.PROMPT_TUNING
+        if self.prompt_tuning_init == PromptTuningInit.TEXT and (not self.tokenizer_name_or_path):
+            raise ValueError(f"When prompt_tuning_init='{PromptTuningInit.TEXT.value}', tokenizer_name_or_path can't be {self.tokenizer_name_or_path}.")
+        if self.prompt_tuning_init == PromptTuningInit.TEXT and self.prompt_tuning_init_text is None:
+            raise ValueError(f"When prompt_tuning_init='{PromptTuningInit.TEXT.value}', prompt_tuning_init_text can't be {self.prompt_tuning_init_text}.")
+        if self.tokenizer_kwargs and self.prompt_tuning_init != PromptTuningInit.TEXT:
+            raise ValueError(f"tokenizer_kwargs only valid when using prompt_tuning_init='{PromptTuningInit.TEXT.value}'.")
+
+# File: peft-main/src/peft/tuners/prompt_tuning/model.py
+import math
+import torch
+from peft.utils.integrations import gather_params_ctx
+from .config import PromptTuningInit
+
+class PromptEmbedding(torch.nn.Module):
+
+    def __init__(self, config, word_embeddings):
+        super().__init__()
+        total_virtual_tokens = config.num_virtual_tokens * config.num_transformer_submodules
+        self.embedding = torch.nn.Embedding(total_virtual_tokens, config.token_dim)
+        if config.prompt_tuning_init == PromptTuningInit.TEXT and (not config.inference_mode):
+            from transformers import AutoTokenizer
+            tokenizer_kwargs = config.tokenizer_kwargs or {}
+            tokenizer = AutoTokenizer.from_pretrained(config.tokenizer_name_or_path, **tokenizer_kwargs)
+            init_text = config.prompt_tuning_init_text
+            init_token_ids = tokenizer(init_text)['input_ids']
+            num_text_tokens = len(init_token_ids)
+            if num_text_tokens > total_virtual_tokens:
+                init_token_ids = init_token_ids[:total_virtual_tokens]
+            elif num_text_tokens < total_virtual_tokens:
+                num_reps = math.ceil(total_virtual_tokens / num_text_tokens)
+                init_token_ids = init_token_ids * num_reps
+            init_token_ids = init_token_ids[:total_virtual_tokens]
+            init_token_ids = torch.LongTensor(init_token_ids).to(word_embeddings.weight.device)
+            with gather_params_ctx(word_embeddings.parameters()):
+                word_embedding_weights = word_embeddings(init_token_ids).detach().clone()
+            word_embedding_weights = word_embedding_weights.to(torch.float32)
+            self.embedding.weight = torch.nn.Parameter(word_embedding_weights)
+
+    def forward(self, indices):
+        prompt_embeddings = self.embedding(indices)
+        return prompt_embeddings
+
+# File: peft-main/src/peft/tuners/tuners_utils.py
+from __future__ import annotations
+import copy
+import logging
+import os
+import re
+import textwrap
+import warnings
+from abc import ABC, abstractmethod
+from contextlib import contextmanager
+from typing import Any, Optional, Union
+import torch
+from accelerate.hooks import AlignDevicesHook
+from accelerate.utils import named_module_tensors, offload_state_dict
+from torch import nn
+from transformers import PreTrainedModel
+from transformers.pytorch_utils import Conv1D
+from peft.utils import INCLUDE_LINEAR_LAYERS_SHORTHAND
+from peft.utils.constants import DUMMY_MODEL_CONFIG, DUMMY_TARGET_MODULES, EMBEDDING_LAYER_NAMES, MIN_TARGET_MODULES_FOR_OPTIMIZATION, SEQ_CLS_HEAD_NAMES
+from peft.utils.peft_types import PeftType, TaskType
+from ..config import PeftConfig
+from ..utils import ModulesToSaveWrapper, _get_submodules
+from ._buffer_dict import BufferDict
+logger = logging.getLogger(__name__)
+
+@contextmanager
+def onload_layer(layer):
+    offloaded_modules = []
+    for (name, module) in layer.named_modules():
+        if name in ['', 'base_layer']:
+            continue
+        if hasattr(module, '_hf_hook') and isinstance(module._hf_hook, AlignDevicesHook) and module._hf_hook.offload:
+            module._hf_hook.pre_forward(module)
+            offloaded_modules.append(module)
+    base_layer_offload = False
+    if hasattr(layer, 'base_layer') and (hasattr(layer.base_layer, '_hf_hook') and isinstance(layer.base_layer._hf_hook, AlignDevicesHook) and layer.base_layer._hf_hook.offload):
+        if torch.device('meta') in layer.base_layer._hf_hook.original_devices.values() and hasattr(layer.base_layer._hf_hook.weights_map, 'dataset'):
+            index = layer.base_layer._hf_hook.weights_map.dataset.index
+            module_name = list(dict(layer.base_layer._hf_hook.weights_map.dataset).keys())[0]
+            file_name = index[module_name]['safetensors_file']
+            base_name_arr = []
+            for i in os.path.split(file_name):
+                if '--' in i:
+                    base_name_arr.append(i)
+                    break
+                base_name_arr.append(i)
+            base_name = os.path.join(*base_name_arr)
+            safetensors_filename = base_name + '-merged'
+        layer.base_layer._hf_hook.pre_forward(layer.base_layer)
+        base_layer_offload = True
+    yield
+    for module in offloaded_modules:
+        module._hf_hook.post_forward(module, torch.tensor([]))
+    if base_layer_offload:
+        layer.base_layer._hf_hook.weights_map = {name: param.to('cpu') for (name, param) in named_module_tensors(layer.base_layer)}
+        if torch.device('meta') in layer.base_layer._hf_hook.original_devices.values() and hasattr(layer.base_layer._hf_hook.weights_map, 'dataset'):
+            offload_state_dict(safetensors_filename, layer.base_layer._hf_hook.weights_map)
+        layer.base_layer._hf_hook.post_forward(layer.base_layer, torch.tensor([]))
+
+class BaseTuner(nn.Module, ABC):
+
+    def __init__(self, model, peft_config: Union[PeftConfig, dict[str, PeftConfig]], adapter_name: str) -> None:
+        super().__init__()
+        self.model = model
+        self.targeted_module_names: list[str] = []
+        if not hasattr(self, 'peft_config'):
+            self.peft_config = {adapter_name: peft_config} if isinstance(peft_config, PeftConfig) else peft_config
+        else:
+            logger.info('Already found a `peft_config` attribute in the model. This will lead to having multiple adapters in the model. Make sure to know what you are doing!')
+            if isinstance(peft_config, PeftConfig):
+                self.peft_config[adapter_name] = peft_config
+            else:
+                self.peft_config.update(peft_config)
+        self.active_adapter: str | list[str] = adapter_name
+        self._pre_injection_hook(self.model, self.peft_config[adapter_name], adapter_name)
+        if peft_config != PeftType.XLORA or peft_config[adapter_name] != PeftType.XLORA:
+            self.inject_adapter(self.model, adapter_name)
+        self.model.peft_config = self.peft_config
+
+    @property
+    def active_adapters(self) -> list[str]:
+        if isinstance(self.active_adapter, str):
+            return [self.active_adapter]
+        return self.active_adapter
+
+    def forward(self, *args: Any, **kwargs: Any):
+        return self.model.forward(*args, **kwargs)
+
+    def _pre_injection_hook(self, model: nn.Module, config: PeftConfig, adapter_name: str) -> None:
+        pass
+
+    @abstractmethod
+    def _prepare_adapter_config(self, peft_config: PeftConfig, model_config: dict) -> PeftConfig:
+        ...
+
+    def _prepare_model(self, peft_config: PeftConfig, model: nn.Module):
+        pass
+
+    @abstractmethod
+    def _check_target_module_exists(peft_config: PeftConfig, key: str) -> bool:
+        ...
+
+    @abstractmethod
+    def _create_and_replace(self, peft_config: PeftConfig, adapter_name: str, target: nn.Module, target_name: str, parent: nn.Module, current_key: str) -> None:
+        ...
+
+    @abstractmethod
+    def _mark_only_adapters_as_trainable(self, model: nn.Module):
+        ...
+
+    @abstractmethod
+    def disable_adapter_layers(self) -> None:
+        ...
+
+    @abstractmethod
+    def enable_adapter_layers(self) -> None:
+        ...
+
+    def _check_new_adapter_config(self, config: PeftConfig) -> None:
+        pass
+
+    def _cast_adapter_dtype(self, adapter_name: str, autocast_adapter_dtype: bool=True) -> None:
+        if not autocast_adapter_dtype:
+            return
+        dtypes_to_convert_to_fp32 = {torch.float16, torch.bfloat16}
+        for module in self.model.modules():
+            if not isinstance(module, BaseTunerLayer):
+                continue
+            for submodule in module.modules():
+                if not isinstance(submodule, (nn.ModuleDict, nn.ParameterDict, BufferDict)):
+                    continue
+                if adapter_name not in submodule:
+                    continue
+                if isinstance(submodule[adapter_name], nn.Parameter):
+                    if submodule[adapter_name].dtype in dtypes_to_convert_to_fp32:
+                        submodule[adapter_name].data = submodule[adapter_name].data.to(torch.float32)
+                    continue
+                if isinstance(submodule[adapter_name], torch.Tensor):
+                    if submodule[adapter_name].dtype in dtypes_to_convert_to_fp32:
+                        submodule[adapter_name] = submodule[adapter_name].to(torch.float32)
+                    continue
+                for param in submodule[adapter_name].parameters():
+                    if param.dtype in dtypes_to_convert_to_fp32:
+                        param.data = param.data.to(torch.float32)
+
+    def _check_merge_allowed(self):
+        example_code = textwrap.dedent('\n            ```python\n            from transformers import AutoModelForCausalLM\n\n            # Load original tied model\n            model = AutoModelForCausalLM.from_pretrained("google/gemma-2-2b-it", tie_word_embeddings=False)\n\n            # Set the randomly initialized lm_head to the previously tied embeddings\n            model.lm_head.weight.data = model.model.embed_tokens.weight.data.clone()\n\n            # Save the untied model\n            untied_model_dir = "dir/for/untied/model"\n            model.save_pretrained(untied_model_dir)\n            model.config.save_pretrained(untied_model_dir)\n\n            # Now use the original model but in untied format\n            model = AutoModelForCausalLM.from_pretrained(untied_model_dir)\n            ```\n            ')
+        tied_target_modules = self._get_tied_target_modules(self.model)
+        if tied_target_modules:
+            warnings.warn(f'Model with `tie_word_embeddings=True` and the tied_target_modules={tied_target_modules!r} are part of the adapter. This can lead to complications. You can opt to merge the adapter after cloning the weights (to untie the embeddings). You can untie the embeddings by loading the model with `tie_word_embeddings=False`. For example:' + example_code)
+
+    def inject_adapter(self, model: nn.Module, adapter_name: str, autocast_adapter_dtype: bool=True) -> None:
+        peft_config = self.peft_config[adapter_name]
+        self._check_new_adapter_config(peft_config)
+        _check_for_modules_to_save = getattr(peft_config, 'modules_to_save', None) is not None
+        _has_modules_to_save = False
+        model_config = self.get_model_config(model)
+        peft_config = self._prepare_adapter_config(peft_config, model_config)
+        self._prepare_model(peft_config, model)
+        is_target_modules_in_base_model = False
+        key_list = [key for (key, _) in model.named_modules()]
+        if getattr(peft_config, 'target_modules', None) == DUMMY_TARGET_MODULES:
+            key_list = []
+            is_target_modules_in_base_model = True
+        peft_config = _maybe_include_all_linear_layers(peft_config, model)
+        if isinstance(peft_config.target_modules, (list, set)) and len(peft_config.target_modules) >= MIN_TARGET_MODULES_FOR_OPTIMIZATION:
+            names_no_target = [name for name in key_list if not any((name.endswith(suffix) for suffix in peft_config.target_modules))]
+            new_target_modules = _find_minimal_target_modules(peft_config.target_modules, names_no_target)
+            if len(new_target_modules) < len(peft_config.target_modules):
+                peft_config.target_modules = new_target_modules
+        for key in key_list:
+            if _check_for_modules_to_save and any((key.endswith(f'{module_to_save}') for module_to_save in peft_config.modules_to_save)):
+                (parent, target, target_name) = _get_submodules(model, key)
+                if not isinstance(target, ModulesToSaveWrapper):
+                    new_module = ModulesToSaveWrapper(target, adapter_name)
+                    setattr(parent, target_name, new_module)
+                else:
+                    target.update(adapter_name)
+                _has_modules_to_save = True
+                continue
+            if not self._check_target_module_exists(peft_config, key):
+                continue
+            self.targeted_module_names.append(key)
+            is_target_modules_in_base_model = True
+            (parent, target, target_name) = _get_submodules(model, key)
+            self._create_and_replace(peft_config, adapter_name, target, target_name, parent, current_key=key)
+        tied_target_modules = self._get_tied_target_modules(model=model)
+        if tied_target_modules:
+            warnings.warn(f'Model with `tie_word_embeddings=True` and the tied_target_modules={tied_target_modules!r} are part of the adapter. This can lead to complications, for example when merging the adapter or converting your model to formats other than safetensors. See for example https://github.com/huggingface/peft/issues/2018.')
+        if not is_target_modules_in_base_model and hasattr(peft_config, 'target_modules'):
+            raise ValueError(f'Target modules {peft_config.target_modules} not found in the base model. Please check the target modules and try again.')
+        self.set_adapter(self.active_adapters)
+        self._mark_only_adapters_as_trainable(model)
+        if self.peft_config[adapter_name].inference_mode:
+            for (n, p) in model.named_parameters():
+                if adapter_name in n:
+                    p.requires_grad = False
+        if _has_modules_to_save:
+            if not hasattr(model, 'modules_to_save'):
+                model.modules_to_save = set(peft_config.modules_to_save)
+            else:
+                model.modules_to_save.update(set(peft_config.modules_to_save))
+
+    def merge_adapter(self, adapter_names: Optional[list[str]]=None) -> None:
+        self._check_merge_allowed()
+        for module in self.model.modules():
+            if isinstance(module, BaseTunerLayer):
+                with onload_layer(module):
+                    module.merge(adapter_names=adapter_names)
+
+    def unmerge_adapter(self):
+        for module in self.model.modules():
+            if isinstance(module, BaseTunerLayer):
+                with onload_layer(module):
+                    module.unmerge()
+
+    def _unloading_checks(self, adapter_names: Optional[list[str]]):
+        adapters_to_consider = adapter_names or self.active_adapters
+        is_modules_to_save_available = any((self.peft_config[adapter].modules_to_save for adapter in adapters_to_consider))
+        if is_modules_to_save_available and len(adapters_to_consider) > 1:
+            raise ValueError('Cannot unload multiple adapters that specify `modules_to_save`.')
+
+    @staticmethod
+    def get_model_config(model: nn.Module) -> dict:
+        model_config = getattr(model, 'config', DUMMY_MODEL_CONFIG)
+        if hasattr(model_config, 'to_dict'):
+            model_config = model_config.to_dict()
+        return model_config
+
+    def _get_tied_target_modules(self, model: nn.Module) -> list[str]:
+        tied_target_modules = []
+        model_config = self.get_model_config(model)
+        if model_config.get('tie_word_embeddings'):
+            for target_module in self.targeted_module_names:
+                if target_module in EMBEDDING_LAYER_NAMES:
+                    tied_target_modules.append(target_module)
+        return tied_target_modules
+
+class BaseTunerLayer(ABC):
+    adapter_layer_names: tuple[str, ...] = ()
+    other_param_names: tuple[str, ...] = ()
+    _disable_adapters: bool = False
+    _active_adapter: str | list[str] = 'default'
+    merged_adapters: list[str] = []
+
+    def get_base_layer(self) -> nn.Module:
+        base_layer = self
+        while hasattr(base_layer, 'base_layer'):
+            base_layer = base_layer.base_layer
+        return base_layer
+
+    @property
+    def weight(self) -> torch.Tensor:
+        base_layer = self.get_base_layer()
+        if hasattr(base_layer, 'qweight'):
+            weight = base_layer.qweight
+        else:
+            weight = base_layer.weight
+        return weight
+
+    @property
+    def bias(self) -> torch.Tensor:
+        base_layer = self.get_base_layer()
+        return base_layer.bias
+
+    def merge(self, safe_merge: bool=False, adapter_names: Optional[list[str]]=None) -> None:
+        raise NotImplementedError
+
+    def unmerge(self) -> None:
+        raise NotImplementedError
+
+    @property
+    def merged(self) -> bool:
+        return bool(self.merged_adapters)
+
+    @property
+    def disable_adapters(self) -> bool:
+        return self._disable_adapters
+
+    @property
+    def active_adapter(self) -> str | list[str]:
+        return self._active_adapter
+
+    def _get_available_adapters(self) -> set[str]:
+        adapters = set()
+        for layer_name in self.adapter_layer_names:
+            module = getattr(self, layer_name)
+            if not isinstance(module, (nn.ModuleDict, nn.ParameterDict)):
+                continue
+            adapters.update(set(module.keys()))
+        return adapters
+
+    @property
+    def active_adapters(self):
+        if isinstance(self.active_adapter, str):
+            return [self.active_adapter]
+        return self.active_adapter
+
+    def enable_adapters(self, enabled: bool) -> None:
+        if enabled:
+            self.set_adapter(self.active_adapters)
+            self._disable_adapters = False
+        else:
+            for layer_name in self.adapter_layer_names:
+                layer = getattr(self, layer_name)
+                layer.requires_grad_(False)
+            self._disable_adapters = True
+
+    def set_adapter(self, adapter_names: str | list[str]) -> None:
+        if isinstance(adapter_names, str):
+            adapter_names = [adapter_names]
+        for layer_name in self.adapter_layer_names:
+            module_dict = getattr(self, layer_name)
+            for (key, layer) in module_dict.items():
+                if key in adapter_names:
+                    layer.requires_grad_(True)
+                else:
+                    layer.requires_grad_(False)
+        self._active_adapter = adapter_names
+
+    def _all_available_adapter_names(self) -> list[str]:
+        adapter_names = set()
+        for name in self.adapter_layer_names + self.other_param_names:
+            attr = getattr(self, name)
+            if hasattr(attr, 'keys'):
+                adapter_names.update(attr.keys())
+        return sorted(adapter_names)
+
+    def delete_adapter(self, adapter_name: str) -> None:
+        for attr in self.adapter_layer_names + self.other_param_names:
+            if adapter_name in getattr(self, attr):
+                del getattr(self, attr)[adapter_name]
+        if adapter_name in self.active_adapters:
+            active_adapters = self.active_adapters[:]
+            active_adapters.remove(adapter_name)
+            if active_adapters:
+                self.set_adapter(active_adapters)
+            else:
+                remaining_adapters = self._all_available_adapter_names()
+                if not remaining_adapters:
+                    self.set_adapter([])
+                else:
+                    new_active_adapter = remaining_adapters[0]
+                    warnings.warn(f'Adapter {adapter_name} was active which is now deleted. Setting active adapter to {new_active_adapter}.')
+                    self.set_adapter(remaining_adapters[0])
+
+    def _move_adapter_to_device_of_base_layer(self, adapter_name: str, device: Optional[torch.device]=None) -> None:
+        if device is None:
+            for weight_name in ('weight', 'qweight'):
+                weight = getattr(self.get_base_layer(), weight_name, None)
+                if weight is not None:
+                    device = weight.device
+                    dtype = weight.dtype
+                    break
+            else:
+                return
+        for adapter_layer_name in self.adapter_layer_names + self.other_param_names:
+            adapter_layer = getattr(self, adapter_layer_name, None)
+            if not isinstance(adapter_layer, (nn.ModuleDict, nn.ParameterDict, BufferDict)):
+                continue
+            if adapter_name not in adapter_layer:
+                continue
+            if weight.dtype.is_floating_point or weight.dtype.is_complex:
+                adapter_layer[adapter_name] = adapter_layer[adapter_name].to(device, dtype=dtype)
+            else:
+                adapter_layer[adapter_name] = adapter_layer[adapter_name].to(device)
+
+def _find_minimal_target_modules(target_modules: list[str] | set[str], other_module_names: list[str] | set[str]) -> set[str]:
+    if isinstance(target_modules, str) or not target_modules:
+        raise ValueError('target_modules should be a list or set of strings.')
+    target_modules = set(target_modules)
+    if '' in target_modules:
+        raise ValueError('target_modules should not contain an empty string.')
+    other_module_names = set(other_module_names)
+    if not target_modules.isdisjoint(other_module_names):
+        msg = 'target_modules and other_module_names contain common elements, this should not happen, please open a GitHub issue at https://github.com/huggingface/peft/issues with the code to reproduce this issue'
+        raise ValueError(msg)
+
+    def generate_suffixes(s):
+        parts = s.split('.')
+        return ['.'.join(parts[i:]) for i in range(len(parts))][::-1]
+    other_module_suffixes = {suffix for item in other_module_names for suffix in generate_suffixes(item)}
+    target_modules_suffix_map = {item: generate_suffixes(item) for item in target_modules}
+    required_suffixes = set()
+    for (item, suffixes) in target_modules_suffix_map.items():
+        for suffix in suffixes:
+            if suffix in required_suffixes or suffix in other_module_suffixes:
+                continue
+            if not any((item.endswith(req_suffix) for req_suffix in required_suffixes)):
+                required_suffixes.add(suffix)
+                break
+    if not required_suffixes:
+        return set(target_modules)
+    return required_suffixes
+
+def check_target_module_exists(config, key: str) -> bool | re.Match[str] | None:
+    if isinstance(config.target_modules, str):
+        target_module_found = re.fullmatch(config.target_modules, key)
+    elif key in config.target_modules:
+        target_module_found = True
+    else:
+        target_module_found = any((key.endswith(f'.{target_key}') for target_key in config.target_modules))
+        layer_indexes = getattr(config, 'layers_to_transform', None)
+        layers_pattern = getattr(config, 'layers_pattern', None)
+        is_using_layer_indexes = layer_indexes is not None and (len(layer_indexes) != 0 if isinstance(layer_indexes, list) else True)
+        if is_using_layer_indexes and target_module_found:
+            layer_index = None
+            if layers_pattern is None or len(layers_pattern) == 0:
+                layer_index = re.match('.*\\.[^.]*\\.(\\d+)\\.', key)
+            else:
+                layers_pattern = [layers_pattern] if isinstance(layers_pattern, str) else layers_pattern
+                for pattern in layers_pattern:
+                    layer_index = re.match(f'.*\\.{pattern}\\.(\\d+)\\.', key)
+                    if layer_index is not None:
+                        break
+            if layer_index is None:
+                target_module_found = False
+            else:
+                layer_index = int(layer_index.group(1))
+                if isinstance(layer_indexes, int):
+                    target_module_found = layer_index == layer_indexes
+                else:
+                    target_module_found = layer_index in layer_indexes
+    return target_module_found
+
+def inspect_matched_modules(tuner: BaseTuner, adapter_name: str='default') -> dict:
+    config = tuner.peft_config[adapter_name]
+    key_list = [key for (key, _) in tuner.model.named_modules()]
+    module_dict = {'matched': [], 'unmatched': []}
+    for key in key_list:
+        if tuner._check_target_module_exists(config, key):
+            module_dict['matched'].append(key)
+        else:
+            module_dict['unmatched'].append(key)
+    return module_dict
+
+def _maybe_include_all_linear_layers(peft_config: PeftConfig, model: nn.Module) -> PeftConfig:
+    if not hasattr(peft_config, 'target_modules'):
+        return peft_config
+    if not (isinstance(peft_config.target_modules, str) and peft_config.target_modules.lower() == INCLUDE_LINEAR_LAYERS_SHORTHAND):
+        return peft_config
+    if not isinstance(model, PreTrainedModel):
+        raise ValueError(f'Only instances of PreTrainedModel support `target_modules={INCLUDE_LINEAR_LAYERS_SHORTHAND!r}`')
+    linear_classes = (torch.nn.Linear, Conv1D)
+    linear_module_names = set()
+    for (name, module) in model.named_modules():
+        if isinstance(module, linear_classes):
+            names = name.rsplit('.', 1)[-1]
+            linear_module_names.add(names)
+    module_names_to_exclude = set()
+    output_emb = model.get_output_embeddings()
+    if output_emb is not None:
+        last_module_name = [name for (name, module) in model.named_modules() if module is output_emb][0]
+        module_names_to_exclude.add(last_module_name)
+    elif peft_config.task_type == TaskType.SEQ_CLS:
+        for name in SEQ_CLS_HEAD_NAMES:
+            cls_head = getattr(model, name, None)
+            if cls_head is not None:
+                last_module_name = [name for (name, module) in model.named_modules() if module is cls_head][0]
+                module_names_to_exclude.add(last_module_name)
+                break
+    linear_module_names -= module_names_to_exclude
+    peft_config.target_modules = linear_module_names
+    return peft_config
+
+def check_adapters_to_merge(module: BaseTunerLayer, adapter_names: Optional[list[str]]=None) -> list[str]:
+    if adapter_names is None:
+        adapter_names = module.active_adapters
+    if isinstance(adapter_names, str):
+        raise ValueError(f'adapter_names should be a list of strings, got {adapter_names!r}.')
+    if module.merged:
+        merged_adapters = set(module.merged_adapters)
+        adapter_names = [name for name in adapter_names if name not in merged_adapters]
+        if adapter_names:
+            warnings.warn(f"Already following adapters were merged {','.join(module.merged_adapters)}. You are now additionally merging {','.join(adapter_names)}.")
+        else:
+            warnings.warn('All adapters are already merged, nothing to do.')
+    return adapter_names
+
+def clone_module(module: nn.Module, share_weights=False):
+    clone = copy.deepcopy(module)
+
+    def _share_weights(src: nn.Module, dst: nn.Module):
+        for (name, param) in src.named_parameters(recurse=False):
+            dst.register_parameter(name, param)
+    if share_weights:
+        for (name, submodule) in module.named_modules():
+            _share_weights(submodule, clone.get_submodule(name))
+    return clone
+
+def replicate_layers(model: nn.Module, layer_map: list[tuple[int, int]]):
+    while hasattr(model, 'model'):
+        model = model.model
+    if hasattr(model, 'bert'):
+        model = model.bert
+    model_type = None
+    layers: nn.ModuleList = None
+    if hasattr(model, 'layers'):
+        model_type = 'llama'
+        layers = model.layers
+    elif hasattr(model, 'encoder') and hasattr(model.encoder, 'layer'):
+        model_type = 'bert'
+        layers = model.encoder.layer
+    elif hasattr(model, 'h'):
+        model_type = 'falcon'
+        layers = model.h
+    if not model_type or not isinstance(layers, nn.ModuleList):
+        raise ValueError('Could not locate the layers attribute in the model. Expected Llama, Bert or Falcon compatible architectures.')
+    new_layers = []
+    for (start, end) in layer_map:
+        for i in range(start, end):
+            current_idx = len(new_layers)
+            new_layers.append(clone_module(layers[i], share_weights=True))
+            for submodule in new_layers[-1].modules():
+                if hasattr(submodule, 'layer_idx'):
+                    submodule.layer_idx = current_idx
+    layers = nn.ModuleList(new_layers)
+    if model_type == 'llama':
+        model.layers = layers
+    elif model_type == 'bert':
+        model.encoder.layer = layers
+    elif model_type == 'falcon':
+        model.h = layers
+    else:
+        raise ValueError('Unexpected model type, need to handle post-processing of layers.')
+    if hasattr(model.config, 'num_hidden_layers'):
+        model.config.num_hidden_layers = len(new_layers)
+
+# File: peft-main/src/peft/tuners/vblora/config.py
+from dataclasses import dataclass, field
+from typing import List, Optional, Union
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+@dataclass
+class VBLoRAConfig(PeftConfig):
+    r: int = field(default=4, metadata={'help': 'The rank of incremental matrices.'})
+    num_vectors: int = field(default=256, metadata={'help': 'Number of vectors in the vector bank. Use higher values when the model size increases.'})
+    vector_length: int = field(default=256, metadata={'help': 'The length of the vectors in the vector bank. The length of the vectors should be divisible by the hidden dimension of the model.'})
+    topk: int = field(default=2, metadata={'help': 'The K value for top-K selection. A larger value of K increases the size of the saved model. In practice, setting K=2 typically provides the best performance and parameter efficiency. For more details, refer to the discussion in the paper.'})
+    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 LoRA.For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'.This can also be a wildcard 'all-linear' which matches all linear/Conv1D layers except the output layer.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."})
+    save_only_topk_weights: bool = field(default=False, metadata={'help': 'Whether to only save the topk weights. Setting `save_only_topk_weights = True` significantly reduces storage space. However, models saved in this mode can be used for merging or inference only, not for resuming training.'})
+    vblora_dropout: float = field(default=0.0, metadata={'help': 'VBLoRA dropout'})
+    fan_in_fan_out: bool = field(default=False, metadata={'help': 'Set this to True if the layer to replace stores weight like (fan_in, fan_out)'})
+    bias: str = field(default='none', metadata={'help': "Bias type for VBLoRA. Can be 'none', 'all' or 'vblora_only'"})
+    modules_to_save: Optional[List[str]] = field(default=None, metadata={'help': 'List of modules apart from VBLoRA 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_vector_bank_bound: float = field(default=0.02, metadata={'help': 'The vector bank is initialized with a uniform distribution between -init_vector_bank_bound and init_vector_bank_bound. Avoid initializing the vector bank with all zeros to prevent zero gradients. A small value, such as 0.02, is typically effective. Initializing with a large value may cause training instability.'})
+    init_logits_std: float = field(default=0.1, metadata={'help': 'The logits are initialized with a normal distribution with a standard deviation of init_logits_std. Default value 0.1 typically works well.'})
+    layers_to_transform: Optional[Union[List[int], int]] = field(default=None, metadata={'help': 'The layer indexes to transform, is this argument is specified, PEFT will transform only the layers indexes that are specified inside this list. If a single integer is passed, PEFT will transform only the layer at this index. This only works when target_modules is a list of str.'})
+    layers_pattern: Optional[Union[List[str], str]] = field(default=None, metadata={'help': 'The layer pattern name, used only if `layers_to_transform` is different to None and if the layer pattern is not in the common layers pattern.This only works when target_modules is a list of str.'})
+
+    def __post_init__(self):
+        self.peft_type = PeftType.VBLORA
+        self.target_modules = set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+
+# File: peft-main/src/peft/tuners/vblora/layer.py
+import warnings
+from typing import List, Optional, Tuple
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from transformers.pytorch_utils import Conv1D
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+from peft.utils.other import transpose
+
+class VBLoRALayer(BaseTunerLayer):
+    adapter_layer_names = ('vblora_logits_A', 'vblora_logits_B', 'vblora_vector_bank')
+
+    def __init__(self, base_layer: nn.Module, **kwargs):
+        self.base_layer = base_layer
+        self.r = {}
+        self.topk = {}
+        self.vblora_dropout = nn.ModuleDict({})
+        self.vblora_logits_A = nn.ParameterDict({})
+        self.vblora_logits_B = nn.ParameterDict({})
+        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)
+        elif isinstance(base_layer, Conv1D):
+            (in_features, out_features) = base_layer.weight.ds_shape if hasattr(base_layer.weight, 'ds_shape') else base_layer.weight.shape
+        self.in_features = in_features
+        self.out_features = out_features
+        self.kwargs = kwargs
+
+    @property
+    def merged(self) -> bool:
+        return bool(self.merged_adapters)
+
+    def update_layer(self, adapter_name: str, vblora_vector_bank, r: int, topk: int, num_vectors: int, vector_length: float, vblora_dropout: float=0.0, init_logits_std: float=0.01):
+        if r <= 0:
+            raise ValueError(f'`r` {r} should be a positive integer value')
+        if topk <= 0:
+            raise ValueError(f'`topk` {topk} should be a positive integer value')
+        if self.in_features % vector_length != 0:
+            raise ValueError(f'`in_features` {self.in_features} must be divisible by `vector_length` {vector_length}')
+        if self.out_features % vector_length != 0:
+            raise ValueError(f'`out_features` {self.out_features} must be divisible by `vector_length` {vector_length}')
+        self.r[adapter_name] = r
+        self.topk[adapter_name] = topk
+        if vblora_dropout > 0.0:
+            vblora_dropout_layer = nn.Dropout(p=vblora_dropout)
+        else:
+            vblora_dropout_layer = nn.Identity()
+        self.vblora_dropout.update(nn.ModuleDict({adapter_name: vblora_dropout_layer}))
+        self.vblora_logits_A[adapter_name] = nn.Parameter(torch.zeros(r, self.in_features // vector_length, num_vectors), requires_grad=True)
+        self.vblora_logits_B[adapter_name] = nn.Parameter(torch.zeros(self.out_features // vector_length, r, num_vectors), requires_grad=True)
+        self.vblora_vector_bank = vblora_vector_bank
+        self.reset_vblora_logits(adapter_name, init_logits_std)
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters)
+
+    def reset_vblora_logits(self, adapter_name, init_logits_std):
+        if adapter_name in self.vblora_logits_A.keys():
+            with torch.no_grad():
+                nn.init.normal_(self.vblora_logits_A[adapter_name], 0, init_logits_std)
+                nn.init.normal_(self.vblora_logits_B[adapter_name], 0, init_logits_std)
+
+class Linear(nn.Linear, VBLoRALayer):
+
+    def __init__(self, base_layer, vblora_vector_bank, adapter_name: str, r: int, num_vectors: int, vector_length: int, topk: int=2, vblora_dropout: float=0.0, init_logits_std: float=0.01, fan_in_fan_out: bool=False, is_target_conv_1d_layer: bool=False, **kwargs) -> None:
+        super(nn.Linear, self).__init__()
+        VBLoRALayer.__init__(self, base_layer, **kwargs)
+        self.fan_in_fan_out = fan_in_fan_out
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, vblora_vector_bank, r, topk, num_vectors, vector_length, vblora_dropout, init_logits_std)
+        self.is_target_conv_1d_layer = is_target_conv_1d_layer
+
+    def merge(self, safe_merge: bool=False, adapter_names: Optional[List[str]]=None) -> None:
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            return
+        for active_adapter in adapter_names:
+            if active_adapter in self.vblora_logits_A.keys():
+                base_layer = self.get_base_layer()
+                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:
+        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.vblora_logits_A.keys():
+                self.get_base_layer().weight.data -= self.get_delta_weight(active_adapter)
+
+    def _get_low_rank_matrix(self, logits: torch.tensor, vblora_vector_bank, topk) -> torch.Tensor:
+        (top_k_logits, indices) = logits.topk(topk, dim=-1)
+        topk_weights = F.softmax(top_k_logits, dim=-1)
+        return (topk_weights.unsqueeze(-1) * vblora_vector_bank[indices]).sum(-2)
+
+    def _get_lora_matrices(self, adapter, cast_to_fp32=False) -> Tuple[torch.Tensor, torch.Tensor]:
+        vblora_logits_A = self.vblora_logits_A[adapter]
+        vblora_logits_B = self.vblora_logits_B[adapter]
+        if self.training and vblora_logits_A[0, 0].isinf().any():
+            raise RuntimeError('Found infinity values in VB-LoRA logits. Ensure training was not resumed from a `save_only_topk_weights` model.')
+        vblora_vector_bank = self.vblora_vector_bank[adapter].to(vblora_logits_A.device)
+        topk = self.topk[adapter]
+        if cast_to_fp32:
+            vblora_logits_A = vblora_logits_A.float()
+            vblora_logits_B = vblora_logits_B.float()
+            vblora_vector_bank = vblora_vector_bank.float()
+        A = self._get_low_rank_matrix(vblora_logits_A, vblora_vector_bank, topk).reshape(vblora_logits_A.shape[0], -1)
+        B = self._get_low_rank_matrix(vblora_logits_B, vblora_vector_bank, topk).transpose(1, 2).reshape(-1, vblora_logits_B.shape[1])
+        return (A, B)
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        device = self.vblora_logits_A[adapter].device
+        dtype = self.vblora_logits_A[adapter].dtype
+        cast_to_fp32 = device.type == 'cpu' and dtype == torch.float16
+        (A, B) = self._get_lora_matrices(adapter, cast_to_fp32)
+        output_tensor = transpose(B @ A, self.fan_in_fan_out)
+        return output_tensor
+
+    def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+        previous_dtype = x.dtype
+        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.vblora_logits_A.keys():
+                    continue
+                (A, B) = self._get_lora_matrices(active_adapter)
+                x = x.to(self.vblora_vector_bank[active_adapter].dtype)
+                dropout = self.vblora_dropout[active_adapter]
+                result = result + F.linear(F.linear(dropout(x), A), B)
+        result = result.to(previous_dtype)
+        return result
+
+# File: peft-main/src/peft/tuners/vblora/model.py
+from __future__ import annotations
+import warnings
+from dataclasses import asdict
+from enum import Enum
+from typing import Optional
+import torch
+import torch.nn as nn
+from tqdm import tqdm
+from transformers.pytorch_utils import Conv1D
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer, check_target_module_exists
+from peft.utils import TRANSFORMERS_MODELS_TO_VBLORA_TARGET_MODULES_MAPPING, ModulesToSaveWrapper, _get_submodules
+from .config import VBLoRAConfig
+from .layer import Linear, VBLoRALayer
+
+class VBLoRAModel(BaseTuner):
+    prefix: str = 'vblora_'
+
+    def __init__(self, model, config, adapter_name) -> None:
+        super().__init__(model, config, adapter_name)
+
+    def _init_vblora_vector_bank(self, config: VBLoRAConfig, adapter_name: str) -> None:
+        vblora_vector_bank = torch.zeros(config.num_vectors, config.vector_length)
+        torch.nn.init.uniform_(vblora_vector_bank, -config.init_vector_bank_bound, config.init_vector_bank_bound)
+        self.vblora_vector_bank[adapter_name] = vblora_vector_bank
+
+    def _pre_injection_hook(self, model: nn.Module, config: VBLoRAConfig, adapter_name: str) -> None:
+        self.vblora_vector_bank = nn.ParameterDict({})
+
+    def _check_new_adapter_config(self, config: VBLoRAConfig) -> None:
+        if len(self.peft_config) > 1 and config.bias != 'none':
+            raise ValueError(f"{self.__class__.__name__} supports only 1 adapter with bias. When using multiple adapters, set bias to 'none' for all adapters.")
+
+    @staticmethod
+    def _check_target_module_exists(vblora_config, key):
+        return check_target_module_exists(vblora_config, key)
+
+    def _create_and_replace(self, vblora_config, adapter_name, target, target_name, parent, current_key):
+        if current_key is None:
+            raise ValueError("Current Key shouldn't be `None`")
+        bias = hasattr(target, 'bias') and target.bias is not None
+        kwargs = {'fan_in_fan_out': vblora_config.fan_in_fan_out, 'bias': bias}
+        self._init_vblora_vector_bank(vblora_config, adapter_name)
+        if isinstance(target, Linear):
+            target.update_layer(adapter_name=adapter_name, vblora_vector_bank=self.vblora_vector_bank, r=vblora_config.r, topk=vblora_config.topk, num_vectors=vblora_config.num_vectors, vector_length=vblora_config.vector_length, vblora_dropout=vblora_config.vblora_dropout, init_logits_std=vblora_config.init_logits_std)
+        else:
+            new_module = self._create_new_module(vblora_config=vblora_config, vblora_vector_bank=self.vblora_vector_bank, adapter_name=adapter_name, target=target, **kwargs)
+            if adapter_name not in self.active_adapter:
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+
+    @staticmethod
+    def _replace_module(parent, child_name, new_module, child):
+        setattr(parent, child_name, new_module)
+        if hasattr(child, 'base_layer'):
+            child = child.base_layer
+        if not hasattr(new_module, 'base_layer'):
+            new_module.weight = child.weight
+            if hasattr(child, 'bias'):
+                new_module.bias = child.bias
+        if getattr(child, 'state', None) is not None:
+            if hasattr(new_module, 'base_layer'):
+                new_module.base_layer.state = child.state
+            else:
+                new_module.state = child.state
+            new_module.to(child.weight.device)
+        for (name, module) in new_module.named_modules():
+            if 'vblora_' in name:
+                module.to(child.weight.device)
+
+    def _mark_only_adapters_as_trainable(self, model: nn.Module) -> None:
+        for (n, p) in model.named_parameters():
+            if self.prefix not in n:
+                p.requires_grad = False
+        for active_adapter in self.active_adapters:
+            bias = self.peft_config[active_adapter].bias
+            if bias == 'none':
+                continue
+            if bias == 'all':
+                for (n, p) in model.named_parameters():
+                    if 'bias' in n:
+                        p.requires_grad = True
+            elif bias == 'vblora_only':
+                for m in model.modules():
+                    if isinstance(m, VBLoRALayer) and hasattr(m, 'bias') and (m.bias is not None):
+                        m.bias.requires_grad = True
+            else:
+                raise NotImplementedError(f'Requested bias: {bias}, is not implemented.')
+
+    @staticmethod
+    def _create_new_module(vblora_config, vblora_vector_bank, 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):
+            if kwargs['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.')
+                kwargs['fan_in_fan_out'] = vblora_config.fan_in_fan_out = False
+        elif isinstance(target_base_layer, Conv1D):
+            kwargs['is_target_conv_1d_layer'] = True
+            if not kwargs['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.')
+                kwargs['fan_in_fan_out'] = vblora_config.fan_in_fan_out = True
+        else:
+            raise ValueError(f'Target module {target} is not supported. Currently, only the following modules are supported: `torch.nn.Linear`, `transformers.pytorch_utils.Conv1D`.')
+        new_module = Linear(base_layer=target, vblora_vector_bank=vblora_vector_bank, adapter_name=adapter_name, r=vblora_config.r, num_vectors=vblora_config.num_vectors, vector_length=vblora_config.vector_length, topk=vblora_config.topk, vblora_dropout=vblora_config.vblora_dropout, init_logits_std=vblora_config.init_logits_std, **kwargs)
+        return new_module
+
+    def __getattr__(self, name: str):
+        try:
+            return super().__getattr__(name)
+        except AttributeError:
+            if name == 'model':
+                raise
+            return getattr(self.model, name)
+
+    def get_peft_config_as_dict(self, inference: bool=False):
+        config_dict = {}
+        for (key, value) in self.peft_config.items():
+            config = {k: v.value if isinstance(v, Enum) else v for (k, v) in asdict(value).items()}
+            if inference:
+                config['inference_mode'] = True
+        config_dict[key] = config
+        return config
+
+    def _set_adapter_layers(self, enabled: bool=True) -> None:
+        for module in self.model.modules():
+            if isinstance(module, (BaseTunerLayer, ModulesToSaveWrapper)):
+                module.enable_adapters(enabled)
+
+    def enable_adapter_layers(self) -> None:
+        self._set_adapter_layers(enabled=True)
+
+    def disable_adapter_layers(self) -> None:
+        for active_adapter in self.active_adapters:
+            val = self.peft_config[active_adapter].bias
+            if val != 'none':
+                msg = f"Careful, disabling adapter layers with bias configured to be '{val}' does not produce the same output as the the base model would without adaption."
+                warnings.warn(msg)
+        self._set_adapter_layers(enabled=False)
+
+    def set_adapter(self, adapter_name: str | list[str]) -> None:
+        for module in self.model.modules():
+            if isinstance(module, VBLoRALayer):
+                if module.merged:
+                    warnings.warn('Adapter cannot be set when the model is merged. Unmerging the model first.')
+                    module.unmerge()
+                module.set_adapter(adapter_name)
+        self.active_adapter = adapter_name
+
+    @staticmethod
+    def _prepare_adapter_config(peft_config, model_config):
+        if peft_config.target_modules is None:
+            if model_config['model_type'] not in TRANSFORMERS_MODELS_TO_VBLORA_TARGET_MODULES_MAPPING:
+                raise ValueError('Please specify `target_modules` in `peft_config`')
+            peft_config.target_modules = set(TRANSFORMERS_MODELS_TO_VBLORA_TARGET_MODULES_MAPPING[model_config['model_type']])
+        return peft_config
+
+    def _unload_and_optionally_merge(self, merge=True, progressbar: bool=False, safe_merge: bool=False, adapter_names: Optional[list[str]]=None):
+        key_list = [key for (key, _) in self.model.named_modules() if self.prefix not in key]
+        desc = 'Unloading ' + ('and merging ' if merge else '') + 'model'
+        for key in tqdm(key_list, disable=not progressbar, desc=desc):
+            try:
+                (parent, target, target_name) = _get_submodules(self.model, key)
+            except AttributeError:
+                continue
+            if hasattr(target, 'base_layer'):
+                if merge:
+                    target.merge(safe_merge=safe_merge, adapter_names=adapter_names)
+                self._replace_module(parent, target_name, target.get_base_layer(), target)
+            elif isinstance(target, ModulesToSaveWrapper):
+                setattr(parent, target_name, target.modules_to_save[target.active_adapter])
+        return self.model
+
+    def delete_adapter(self, adapter_name: str) -> None:
+        if adapter_name not in list(self.peft_config.keys()):
+            raise ValueError(f'Adapter {adapter_name} does not exist')
+        del self.peft_config[adapter_name]
+        key_list = [key for (key, _) in self.model.named_modules() if self.prefix not in key]
+        new_adapter = None
+        for key in key_list:
+            (_, target, _) = _get_submodules(self.model, key)
+            if isinstance(target, VBLoRALayer):
+                target.delete_adapter(adapter_name)
+                if new_adapter is None:
+                    new_adapter = target.active_adapter[:]
+        self.active_adapter = new_adapter or []
+
+    def merge_and_unload(self, progressbar: bool=False, safe_merge: bool=False, adapter_names: Optional[list[str]]=None) -> torch.nn.Module:
+        return self._unload_and_optionally_merge(progressbar=progressbar, safe_merge=safe_merge, adapter_names=adapter_names)
+
+    def unload(self):
+        return self._unload_and_optionally_merge(merge=False)
+
+    def get_nb_savable_parameters(self, adapter='default') -> tuple[int, int]:
+        logits_params = 0
+        vector_bank_params = 0
+        other_params = 0
+        for (name, param) in self.named_parameters():
+            if 'vblora_logits' in name:
+                logits_params += param.numel()
+            elif 'vblora_vector_bank' in name:
+                vector_bank_params += param.numel()
+            elif param.requires_grad:
+                other_params += param.numel()
+        if self.peft_config[adapter].save_only_topk_weights:
+            num_vectors = self.peft_config[adapter].num_vectors
+            factor = 1
+            if num_vectors < 2 ** 8:
+                factor = 0.25
+            elif num_vectors < 2 ** 15:
+                factor = 0.5
+            elif num_vectors < 2 ** 31:
+                factor = 1
+            else:
+                factor = 2
+            topk_weight_params = logits_params / self.peft_config[adapter].num_vectors * (self.peft_config[adapter].topk - 1)
+            topk_indices_params = logits_params / self.peft_config[adapter].num_vectors * self.peft_config[adapter].topk * factor
+            vblora_params = int(vector_bank_params + topk_weight_params + topk_indices_params)
+        else:
+            vblora_params = vector_bank_params + logits_params
+        return (vblora_params, other_params)
+
+    def print_savable_parameters(self) -> None:
+        (vblora_params, other_params) = self.get_nb_savable_parameters()
+        print(f'VB-LoRA params to-be-saved (float32-equivalent): {vblora_params:,d} || total params to-be-saved: {vblora_params + other_params:,d}')
+
+# File: peft-main/src/peft/tuners/vera/config.py
+import warnings
+from dataclasses import dataclass, field
+from typing import List, Optional, Union
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+@dataclass
+class VeraConfig(PeftConfig):
+    r: int = field(default=256, metadata={'help': 'Vera attention dimension'})
+    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 Vera.For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'. Only linear layers are supported."})
+    projection_prng_key: int = field(default=0, metadata={'help': 'Vera PRNG init key. Used for initialising vera_A and vera_B for new models or when loading a checkpoint that did not include these projections.'})
+    save_projection: bool = field(default=True, metadata={'help': 'Whether to save the vera_A / vera_B projections in the state dict alongside per layer lambda_b / lambda_d weights. This will increase the size of the checkpoint, but guarantee that we can reload the checkpoint on all system configurations.'})
+    vera_dropout: float = field(default=0.0, metadata={'help': 'Vera dropout'})
+    d_initial: float = field(default=0.1, metadata={'help': 'Initial init value for d vector.'})
+    fan_in_fan_out: bool = field(default=False, metadata={'help': 'Set this to True if the layer to replace stores weight like (fan_in, fan_out)'})
+    bias: str = field(default='none', metadata={'help': "Bias type for Vera. Can be 'none', 'all' or 'vera_only'"})
+    modules_to_save: Optional[List[str]] = field(default=None, metadata={'help': 'List of modules apart from Vera 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 weights of the Vera layers with their default initialization. Don't change this setting, except if you know exactly what you're doing."})
+    layers_to_transform: Optional[Union[List[int], int]] = field(default=None, metadata={'help': 'The layer indexes to transform, is this argument is specified, PEFT will transform only the layers indexes that are specified inside this list. If a single integer is passed, PEFT will transform only the layer at this index.'})
+    layers_pattern: Optional[str] = field(default=None, metadata={'help': 'The layer pattern name, used only if `layers_to_transform` is different to None and if the layer pattern is not in the common layers pattern.'})
+
+    def __post_init__(self):
+        self.peft_type = PeftType.VERA
+        self.target_modules = set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        if not self.save_projection:
+            warnings.warn('Specified to not save vera_A and vera_B within the state dictionary, instead they will be restored using the PRNG key store in `config.projection_prng_key`. Consider setting `config.save_projection` to `True` to guarantee restoring the checkpoint correctly on all system configurations.')
+
+# File: peft-main/src/peft/tuners/vera/layer.py
+import warnings
+from typing import List, Optional
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from transformers.pytorch_utils import Conv1D
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+from peft.utils.other import transpose
+from .._buffer_dict import BufferDict
+
+class VeraLayer(BaseTunerLayer):
+    adapter_layer_names = ('vera_lambda_b', 'vera_lambda_d')
+    other_param_names = ('vera_A', 'vera_B')
+
+    def __init__(self, base_layer: nn.Module, **kwargs):
+        self.base_layer = base_layer
+        self.r = {}
+        self.vera_dropout = nn.ModuleDict({})
+        self.vera_lambda_b = nn.ParameterDict({})
+        self.vera_lambda_d = nn.ParameterDict({})
+        self.vera_A: Optional[BufferDict] = None
+        self.vera_B: Optional[BufferDict] = None
+        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)
+        elif isinstance(base_layer, Conv1D):
+            (in_features, out_features) = base_layer.weight.ds_shape if hasattr(base_layer.weight, 'ds_shape') else base_layer.weight.shape
+        self.in_features = in_features
+        self.out_features = out_features
+        self.kwargs = kwargs
+
+    @property
+    def merged(self) -> bool:
+        return bool(self.merged_adapters)
+
+    def update_layer(self, adapter_name, vera_A: BufferDict, vera_B: BufferDict, r, vera_dropout, init_weights, d_initial: float=0.1):
+        if r <= 0:
+            raise ValueError(f'`r` should be a positive integer value but the value passed is {r}')
+        self.r[adapter_name] = r
+        if vera_dropout > 0.0:
+            vera_dropout_layer = nn.Dropout(p=vera_dropout)
+        else:
+            vera_dropout_layer = nn.Identity()
+        self.vera_dropout.update(nn.ModuleDict({adapter_name: vera_dropout_layer}))
+        self.vera_lambda_b[adapter_name] = nn.Parameter(torch.ones(self.out_features), requires_grad=True)
+        self.vera_lambda_d[adapter_name] = nn.Parameter(torch.randn(r), requires_grad=True)
+        self.vera_A = vera_A
+        self.vera_B = vera_B
+        if adapter_name not in vera_A:
+            if len(self.vera_A) < 1:
+                raise ValueError('The `vera_A` and `vera_B` buffers are empty. This should not happen. Please report this issue.')
+            vera_A_param = list(self.vera_A.values())[0]
+            vera_B_param = list(self.vera_B.values())[0]
+            error_tmpl = '{} has a size of {} but {} or greater is required; this probably happened because an additional VeRA adapter was added after the first one with incompatible shapes.'
+            if vera_A_param.shape[1] < self.in_features:
+                raise ValueError(error_tmpl.format('vera_A', vera_A_param.shape[1], self.in_features))
+            if vera_B_param.shape[0] < self.out_features:
+                raise ValueError(error_tmpl.format('vera_B', vera_B_param.shape[0], self.out_features))
+            error_tmpl = '{} has a size of {} but {} or greater is required; this probably happened because an additional VeRA adapter with a lower rank was added after the first one; loading the adapters in reverse order may solve this.'
+            if vera_A_param.shape[0] < self.r[adapter_name]:
+                raise ValueError(error_tmpl.format('vera_A', vera_A_param.shape[0], self.r[adapter_name]))
+            if vera_B_param.shape[1] < self.r[adapter_name]:
+                raise ValueError(error_tmpl.format('vera_B', vera_B_param.shape[1], self.r[adapter_name]))
+            self.vera_A[adapter_name] = vera_A_param
+            self.vera_B[adapter_name] = vera_B_param
+        if init_weights:
+            self.reset_vera_parameters(adapter_name, d_initial=d_initial)
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters)
+
+    def reset_vera_parameters(self, adapter_name, d_initial: float=0.1):
+        if adapter_name in self.vera_lambda_d.keys():
+            with torch.no_grad():
+                nn.init.zeros_(self.vera_lambda_d[adapter_name]).fill_(d_initial)
+                nn.init.zeros_(self.vera_lambda_b[adapter_name])
+
+class Linear(nn.Linear, VeraLayer):
+
+    def __init__(self, base_layer, vera_A: BufferDict, vera_B: BufferDict, adapter_name: str, r: int=0, vera_dropout: float=0.0, fan_in_fan_out: bool=False, is_target_conv_1d_layer: bool=False, init_weights: bool=True, d_initial: float=0.1, **kwargs) -> None:
+        super(nn.Linear, self).__init__()
+        VeraLayer.__init__(self, base_layer, **kwargs)
+        self.fan_in_fan_out = fan_in_fan_out
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, vera_A, vera_B, r, vera_dropout, init_weights, d_initial=d_initial)
+        self.is_target_conv_1d_layer = is_target_conv_1d_layer
+
+    def merge(self, safe_merge: bool=False, adapter_names: Optional[List[str]]=None) -> None:
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            return
+        for active_adapter in adapter_names:
+            if active_adapter in self.vera_lambda_d.keys():
+                base_layer = self.get_base_layer()
+                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:
+        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.vera_lambda_d.keys():
+                self.get_base_layer().weight.data -= self.get_delta_weight(active_adapter)
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        vera_A = self.vera_A[adapter]
+        vera_B = self.vera_B[adapter]
+        device = vera_B.device
+        dtype = vera_B.dtype
+        cast_to_fp32 = device.type == 'cpu' and (dtype == torch.float16 or dtype == torch.bfloat16)
+        lambda_d = self.vera_lambda_d[adapter]
+        lambda_b = self.vera_lambda_b[adapter]
+        if cast_to_fp32:
+            vera_A = vera_A.float()
+            vera_B = vera_B.float()
+            lambda_d = lambda_d.float()
+            lambda_b = lambda_b.float()
+        sliced_A = vera_A[:, :self.in_features]
+        sliced_B = vera_B[:self.out_features, :]
+        lambda_b = lambda_b.unsqueeze(-1)
+        lambda_d = lambda_d.unsqueeze(-1)
+        output_tensor = transpose(lambda_b * sliced_B @ (lambda_d * sliced_A), self.fan_in_fan_out)
+        if cast_to_fp32:
+            output_tensor = output_tensor.to(dtype=dtype)
+            self.vera_lambda_d[adapter].data = lambda_d.to(dtype)
+            self.vera_lambda_b[adapter].data = lambda_b.to(dtype)
+        return output_tensor
+
+    def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+        previous_dtype = x.dtype
+        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.vera_lambda_d.keys():
+                    continue
+                lambda_d = self.vera_lambda_d[active_adapter]
+                lambda_b = self.vera_lambda_b[active_adapter]
+                vera_A = self.vera_A[active_adapter]
+                vera_B = self.vera_B[active_adapter]
+                sliced_A = vera_A[:, :self.in_features]
+                sliced_B = vera_B[:self.out_features, :]
+                dropout = self.vera_dropout[active_adapter]
+                x = x.to(lambda_d.dtype)
+                result = result + lambda_b * F.linear(lambda_d * F.linear(dropout(x), sliced_A), sliced_B)
+        result = result.to(previous_dtype)
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return 'vera.' + rep
+
+# File: peft-main/src/peft/tuners/vera/model.py
+from __future__ import annotations
+import math
+import warnings
+from dataclasses import asdict
+from enum import Enum
+from typing import Optional, Union
+import torch
+import torch.nn as nn
+from torch.nn.init import _calculate_correct_fan
+from tqdm import tqdm
+from transformers.pytorch_utils import Conv1D
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer, check_target_module_exists
+from peft.utils import TRANSFORMERS_MODELS_TO_VERA_TARGET_MODULES_MAPPING, ModulesToSaveWrapper, _get_submodules
+from .._buffer_dict import BufferDict
+from ..tuners_utils import _maybe_include_all_linear_layers
+from .config import VeraConfig
+from .layer import Linear, VeraLayer
+
+def _kaiming_init(tensor_or_shape: Union[torch.Tensor, tuple[int, ...]], generator: torch.Generator) -> torch.Tensor:
+    if isinstance(tensor_or_shape, tuple):
+        tensor = torch.empty(tensor_or_shape)
+    else:
+        tensor = tensor_or_shape
+    fan = _calculate_correct_fan(tensor, 'fan_in')
+    gain = math.sqrt(2)
+    std = gain / math.sqrt(fan)
+    bound = math.sqrt(3.0) * std
+    with torch.no_grad():
+        return tensor.uniform_(-bound, bound, generator=generator)
+
+class VeraModel(BaseTuner):
+    prefix: str = 'vera_lambda'
+
+    def __init__(self, model, config, adapter_name) -> None:
+        super().__init__(model, config, adapter_name)
+
+    def _find_dim(self, config) -> tuple[int, int]:
+        model_config = self.get_model_config(self.model)
+        peft_config = self._prepare_adapter_config(config, model_config)
+        peft_config = _maybe_include_all_linear_layers(peft_config, self.model)
+        largest_shape = None
+        for (key, module) in self.model.named_modules():
+            if not self._check_target_module_exists(peft_config, key):
+                continue
+            if isinstance(module, (nn.Linear, Conv1D)):
+                module_shape = tuple(module.weight.shape)
+                if isinstance(module, Conv1D):
+                    module_shape = module_shape[::-1]
+            else:
+                continue
+            if largest_shape is None:
+                largest_shape = module_shape
+                continue
+            if module_shape != largest_shape:
+                largest_shape = tuple((max(a, b) for (a, b) in zip(largest_shape, module_shape)))
+        if largest_shape is None:
+            msg = 'No layers types compatible with VeRA were found. Please check `peft_config.target_modules`.'
+            raise ValueError(msg)
+        return largest_shape
+
+    def _init_vera_A_vera_B(self, config: VeraConfig, adapter_name: str) -> None:
+        (linear_out_dim, linear_in_dim) = self._find_dim(config)
+        self.vera_A = BufferDict({}, persistent=config.save_projection)
+        self.vera_B = BufferDict({}, persistent=config.save_projection)
+        generator = torch.Generator(device='cpu').manual_seed(config.projection_prng_key)
+        vera_A = _kaiming_init((config.r, linear_in_dim), generator=generator)
+        vera_B = _kaiming_init((linear_out_dim, config.r), generator=generator)
+        self.vera_A[adapter_name] = vera_A
+        self.vera_B[adapter_name] = vera_B
+
+    def _pre_injection_hook(self, model: nn.Module, config: VeraConfig, adapter_name: str) -> None:
+        self._init_vera_A_vera_B(config, adapter_name)
+
+    def _check_new_adapter_config(self, config: VeraConfig) -> None:
+        if len(self.peft_config) > 1 and config.bias != 'none':
+            raise ValueError(f"{self.__class__.__name__} supports only 1 adapter with bias. When using multiple adapters, set bias to 'none' for all adapters.")
+        for existing_config in self.peft_config.values():
+            if existing_config is config:
+                continue
+            if existing_config.projection_prng_key != config.projection_prng_key:
+                raise ValueError(f'Vera PRNG initialisation key must be the same for all adapters. Got config.projection_prng_key={config.projection_prng_key!r} but previous config had {existing_config.projection_prng_key}.')
+        save_project_unique_values = sorted({config.save_projection for config in self.peft_config.values()})
+        if len(save_project_unique_values) > 1:
+            raise ValueError(f'VeRA projection weights must be saved for all adapters or none, but got multiple different values: {save_project_unique_values}')
+
+    @staticmethod
+    def _check_target_module_exists(vera_config, key):
+        return check_target_module_exists(vera_config, key)
+
+    def _create_and_replace(self, vera_config, adapter_name, target, target_name, parent, current_key, **optional_kwargs):
+        if current_key is None:
+            raise ValueError("Current Key shouldn't be `None`")
+        r = vera_config.r
+        bias = hasattr(target, 'bias') and target.bias is not None
+        kwargs = {'r': r, 'vera_dropout': vera_config.vera_dropout, 'fan_in_fan_out': vera_config.fan_in_fan_out, 'init_weights': vera_config.init_weights}
+        kwargs['bias'] = bias
+        if isinstance(target, Linear):
+            target.update_layer(adapter_name, self.vera_A, self.vera_B, r, vera_config.vera_dropout, vera_config.init_weights, d_initial=vera_config.d_initial)
+        else:
+            new_module = self._create_new_module(vera_config, self.vera_A, self.vera_B, adapter_name, target, **kwargs)
+            if adapter_name not in self.active_adapter:
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+
+    @staticmethod
+    def _replace_module(parent, child_name, new_module, child):
+        setattr(parent, child_name, new_module)
+        if hasattr(child, 'base_layer'):
+            child = child.base_layer
+        if not hasattr(new_module, 'base_layer'):
+            new_module.weight = child.weight
+            if hasattr(child, 'bias'):
+                new_module.bias = child.bias
+        if getattr(child, 'state', None) is not None:
+            if hasattr(new_module, 'base_layer'):
+                new_module.base_layer.state = child.state
+            else:
+                new_module.state = child.state
+            new_module.to(child.weight.device)
+        for (name, module) in new_module.named_modules():
+            if 'vera_' in name:
+                module.to(child.weight.device)
+
+    def _mark_only_adapters_as_trainable(self, model: nn.Module) -> None:
+        for (n, p) in model.named_parameters():
+            if self.prefix not in n:
+                p.requires_grad = False
+        for active_adapter in self.active_adapters:
+            bias = self.peft_config[active_adapter].bias
+            if bias == 'none':
+                continue
+            if bias == 'all':
+                for (n, p) in model.named_parameters():
+                    if 'bias' in n:
+                        p.requires_grad = True
+            elif bias == 'vera_only':
+                for m in model.modules():
+                    if isinstance(m, VeraLayer) and hasattr(m, 'bias') and (m.bias is not None):
+                        m.bias.requires_grad = True
+            else:
+                raise NotImplementedError(f'Requested bias: {bias}, is not implemented.')
+
+    @staticmethod
+    def _create_new_module(vera_config, vera_A, vera_B, adapter_name, target, **kwargs):
+        bias = kwargs.pop('bias', False)
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+        if isinstance(target_base_layer, torch.nn.Linear):
+            if kwargs['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.')
+                kwargs['fan_in_fan_out'] = vera_config.fan_in_fan_out = False
+        elif isinstance(target_base_layer, Conv1D):
+            kwargs['is_target_conv_1d_layer'] = True
+            if not kwargs['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.')
+                kwargs['fan_in_fan_out'] = vera_config.fan_in_fan_out = True
+        else:
+            raise ValueError(f'Target module {target} is not supported. Currently, only the following modules are supported: `torch.nn.Linear`, `transformers.pytorch_utils.Conv1D`.')
+        new_module = Linear(target, vera_A, vera_B, adapter_name, bias=bias, d_initial=vera_config.d_initial, **kwargs)
+        return new_module
+
+    def __getattr__(self, name: str):
+        try:
+            return super().__getattr__(name)
+        except AttributeError:
+            if name == 'model':
+                raise
+            return getattr(self.model, name)
+
+    def get_peft_config_as_dict(self, inference: bool=False):
+        config_dict = {}
+        for (key, value) in self.peft_config.items():
+            config = {k: v.value if isinstance(v, Enum) else v for (k, v) in asdict(value).items()}
+            if inference:
+                config['inference_mode'] = True
+        config_dict[key] = config
+        return config
+
+    def _set_adapter_layers(self, enabled=True):
+        for module in self.model.modules():
+            if isinstance(module, (BaseTunerLayer, ModulesToSaveWrapper)):
+                module.enable_adapters(enabled)
+
+    def enable_adapter_layers(self):
+        self._set_adapter_layers(enabled=True)
+
+    def disable_adapter_layers(self):
+        for active_adapter in self.active_adapters:
+            val = self.peft_config[active_adapter].bias
+            if val != 'none':
+                msg = f"Careful, disabling adapter layers with bias configured to be '{val}' does not produce the same output as the the base model would without adaption."
+                warnings.warn(msg)
+        self._set_adapter_layers(enabled=False)
+
+    def set_adapter(self, adapter_name):
+        for module in self.model.modules():
+            if isinstance(module, VeraLayer):
+                if module.merged:
+                    warnings.warn('Adapter cannot be set when the model is merged. Unmerging the model first.')
+                    module.unmerge()
+                module.set_adapter(adapter_name)
+        self.active_adapter = adapter_name
+
+    @staticmethod
+    def _prepare_adapter_config(peft_config, model_config):
+        if peft_config.target_modules is None:
+            if model_config['model_type'] not in TRANSFORMERS_MODELS_TO_VERA_TARGET_MODULES_MAPPING:
+                raise ValueError('Please specify `target_modules` in `peft_config`')
+            peft_config.target_modules = set(TRANSFORMERS_MODELS_TO_VERA_TARGET_MODULES_MAPPING[model_config['model_type']])
+        return peft_config
+
+    def _unload_and_optionally_merge(self, merge=True, progressbar: bool=False, safe_merge: bool=False, adapter_names: Optional[list[str]]=None):
+        key_list = [key for (key, _) in self.model.named_modules() if 'vera' not in key]
+        desc = 'Unloading ' + ('and merging ' if merge else '') + 'model'
+        for key in tqdm(key_list, disable=not progressbar, desc=desc):
+            try:
+                (parent, target, target_name) = _get_submodules(self.model, key)
+            except AttributeError:
+                continue
+            if hasattr(target, 'base_layer'):
+                if merge:
+                    target.merge(safe_merge=safe_merge, adapter_names=adapter_names)
+                self._replace_module(parent, target_name, target.get_base_layer(), target)
+            elif isinstance(target, ModulesToSaveWrapper):
+                setattr(parent, target_name, target.modules_to_save[target.active_adapter])
+        return self.model
+
+    def delete_adapter(self, adapter_name: str):
+        if adapter_name not in list(self.peft_config.keys()):
+            raise ValueError(f'Adapter {adapter_name} does not exist')
+        del self.peft_config[adapter_name]
+        key_list = [key for (key, _) in self.model.named_modules() if 'vera' not in key]
+        new_adapter = None
+        for key in key_list:
+            (_, target, _) = _get_submodules(self.model, key)
+            if isinstance(target, VeraLayer):
+                target.delete_adapter(adapter_name)
+                if new_adapter is None:
+                    new_adapter = target.active_adapter[:]
+        self.active_adapter = new_adapter or []
+
+    def merge_and_unload(self, progressbar: bool=False, safe_merge: bool=False, adapter_names: Optional[list[str]]=None):
+        return self._unload_and_optionally_merge(progressbar=progressbar, safe_merge=safe_merge, adapter_names=adapter_names)
+
+    def unload(self):
+        return self._unload_and_optionally_merge(merge=False)
+
+# File: peft-main/src/peft/tuners/xlora/classifier.py
+from __future__ import annotations
+import builtins
+from typing import Optional, Union
+import torch
+import torch.nn as nn
+from .config import XLoraConfig
+Number = Union[builtins.int, builtins.float, builtins.bool]
+
+class TemperatureScaledSoftmax(nn.Module):
+
+    def __init__(self, temperature=1.0):
+        super().__init__()
+        self.temperature = temperature
+        self.softmax = nn.Softmax(dim=-1)
+
+    def forward(self, logits):
+        scaled_logits = logits / self.temperature
+        return self.softmax(scaled_logits)
+
+class XLoraClassifier(nn.Module):
+
+    def __init__(self, model: nn.Module, config: XLoraConfig, n_classes: int, n_layers: int, device: torch.device):
+        super().__init__()
+        self.n_classes = n_classes
+        self.n_layers = n_layers
+        self.config = config
+        self.log_scalings = []
+        self.softmax = TemperatureScaledSoftmax(temperature=self.config.softmax_temperature)
+        self.override_scaling_pass_value: Number = config.scaling_pass_value
+        self.scalings_logging = False
+        self.dtype = next(model.parameters()).dtype
+        add_dropout = config.xlora_dropout_p > 0.0
+        layers = []
+        if self.config.xlora_depth == 1:
+            if config.layerwise_scalings:
+                last = nn.Linear(config.hidden_size, n_classes * n_layers, bias=True).to(device).to(self.dtype)
+            else:
+                last = nn.Linear(config.hidden_size, n_classes, bias=True).to(device).to(self.dtype)
+        else:
+            if self.config.xlora_depth <= 0:
+                raise ValueError('X-LoRA depth must be strictly positive.')
+            layers.append(nn.Linear(config.hidden_size, config.xlora_size, bias=True).to(device).to(self.dtype))
+            layers.append(nn.ReLU())
+            if add_dropout:
+                layers.append(nn.Dropout(p=config.xlora_dropout_p))
+            for _ in range(config.xlora_depth - 2):
+                layers.append(nn.Linear(config.xlora_size, config.xlora_size, bias=True).to(device).to(self.dtype))
+                layers.append(nn.ReLU())
+                if add_dropout:
+                    layers.append(nn.Dropout(p=config.xlora_dropout_p))
+            if config.layerwise_scalings:
+                last = nn.Linear(config.xlora_size, n_classes * n_layers, bias=True).to(device).to(self.dtype)
+            else:
+                last = nn.Linear(config.xlora_size, n_classes, bias=True).to(device).to(self.dtype)
+        self.layers = nn.Sequential(*layers, last)
+
+    def make_dummy_scalings(self, input_ids: Optional[torch.LongTensor]=None, inputs_embeds: Optional[torch.FloatTensor]=None, *args, **kwargs) -> torch.Tensor:
+        if input_ids is not None:
+            batch_size = input_ids.shape[0]
+            device = input_ids.device
+            seq_len = input_ids.shape[1]
+        else:
+            batch_size = inputs_embeds.shape[0]
+            device = inputs_embeds.device
+            seq_len = inputs_embeds.shape[1]
+        return torch.full((batch_size, seq_len, self.n_layers, self.n_classes), self.override_scaling_pass_value).to(device=device, dtype=self.dtype)
+
+    def forward(self, result, input_ids: Optional[torch.LongTensor]=None, inputs_embeds: Optional[torch.FloatTensor]=None, *args, **kwargs) -> torch.Tensor:
+        if input_ids is not None:
+            batch_size = input_ids.shape[0]
+            seq_len = input_ids.shape[1]
+        else:
+            batch_size = inputs_embeds.shape[0]
+            seq_len = inputs_embeds.shape[1]
+        hidden_states = result.hidden_states
+        hidden_state = hidden_states[-1]
+        logits = self.layers.forward(hidden_state)
+        if not self.config.layerwise_scalings:
+            logits = logits.unsqueeze(2)
+            logits = logits.expand(-1, -1, self.n_layers, -1)
+        scalings = logits.reshape(batch_size, seq_len, self.n_layers, self.n_classes)
+        if self.config.enable_softmax:
+            scalings = self.softmax(scalings)
+        if self.scalings_logging:
+            self.log_scalings.append(scalings)
+        return scalings
+
+    def _get_bucketed_scalings(self) -> dict[int, tuple[list[int], list[torch.Tensor]]]:
+        seqlens_map: dict[int, tuple[list[int], list[torch.Tensor]]] = {}
+        for (i, scaling) in enumerate(self.log_scalings):
+            seq_len = scaling.shape[1]
+            if seq_len not in seqlens_map:
+                seqlens_map[seq_len] = ([i], [scaling])
+            else:
+                seqlens_map[seq_len][0].append(i)
+                seqlens_map[seq_len][1].append(scaling)
+        return seqlens_map
+
+    def _set_override_scaling_pass_value(self, value: Union[Number, None]):
+        if value is None:
+            self.override_scaling_pass_value = 1 / self.n_classes
+        else:
+            self.override_scaling_pass_value = value
+        self.config.scaling_pass_value = self.override_scaling_pass_value
+
+# File: peft-main/src/peft/tuners/xlora/config.py
+from __future__ import annotations
+import warnings
+from dataclasses import dataclass
+from typing import Optional
+from peft.config import PeftConfig
+from peft.utils.peft_types import PeftType
+
+@dataclass
+class XLoraConfig(PeftConfig):
+    hidden_size: int = None
+    adapters: dict[str, str] = None
+    enable_softmax: bool = True
+    enable_softmax_topk: bool = False
+    layerwise_scalings: bool = False
+    xlora_depth: int = 1
+    xlora_size: int = 2048
+    xlora_dropout_p: float = 0.2
+    use_trainable_adapters: bool = False
+    softmax_temperature: float = 1.0
+    top_k_lora: Optional[int] = None
+    scaling_pass_value: float = 0.0
+    global_scaling_weight: float = 1.0
+
+    def __post_init__(self):
+        self.peft_type = PeftType.XLORA
+        if self.hidden_size is None:
+            warnings.warn('No value was provided for `hidden_size`. This will be set to 4096 by default, please ensure that this is correct.')
+            self.hidden_size = 4096
+        if self.adapters is None:
+            warnings.warn('No value was provided for for `adapters`. This will be set to empty, please ensure that this is correct.')
+            self.adapters = {}
+        if self.enable_softmax_topk and self.top_k_lora is None:
+            warnings.warn('`enable_softmax_topk` enabled `top_k_lora` is not set')
+        if self.enable_softmax_topk and self.enable_softmax:
+            warnings.warn('`enable_softmax_topk` and `enable_softmax` are both enabled. This will result in worse performance.')
+        if self.top_k_lora is not None and self.top_k_lora < 1:
+            warnings.warn('`top_k_lora` value must be at least 1.')
+
+# File: peft-main/src/peft/tuners/xlora/layer.py
+from __future__ import annotations
+from typing import Any, Callable, Optional
+import torch
+import torch.nn as nn
+from torch import Tensor
+from peft.tuners import lora
+from .config import XLoraConfig
+
+class XLoraLayer:
+
+    def __init__(self, model: nn.Module, target: lora.LoraLayer, target_forward: Callable[..., Any], layer_number: int, config: XLoraConfig) -> None:
+        self.model = model
+        self.target_forward = target_forward
+        self.target = target
+        self.layer_number = layer_number
+        self.config = config
+    ''
+
+    @staticmethod
+    def apply_scalings_to_x(x: torch.Tensor, scalings_layer: torch.Tensor, adapter: int) -> torch.Tensor:
+        scalings = scalings_layer[:, :, adapter].unsqueeze(-1)
+        return x * scalings
+    ''
+
+    def get_maybe_topk_scalings(self, scalings) -> torch.Tensor:
+        xlora_scalings: Tensor = scalings[:, :, self.layer_number, :]
+        if self.config.top_k_lora is not None:
+            (_, topk_indices) = torch.topk(xlora_scalings, k=self.config.top_k_lora, dim=-1)
+            mask = torch.zeros_like(xlora_scalings, dtype=torch.bool)
+            mask.scatter_(-1, topk_indices, True)
+            xlora_scalings = xlora_scalings * mask.to(xlora_scalings.dtype)
+        if self.config.enable_softmax_topk:
+            nonzero_mask = xlora_scalings != 0
+            softmax_res_nonzero = torch.softmax(xlora_scalings[nonzero_mask], dim=-1)
+            xlora_scalings[nonzero_mask] = softmax_res_nonzero
+        return xlora_scalings
+
+class XLoraLinearLayer(XLoraLayer):
+
+    def __init__(self, model: nn.Module, target: lora.Linear, target_forward: Callable[..., Any], layer_number: int, config: XLoraConfig) -> None:
+        super().__init__(model, target, target_forward, layer_number, config)
+
+    def forward(self, x: Tensor, *args: Any, scalings: Optional[Tensor]=None, **kwargs: Any) -> Tensor:
+        previous_dtype = x.dtype
+        if scalings is not None:
+            xlora_scalings = self.get_maybe_topk_scalings(scalings)
+        result = self.target.base_layer(x, *args, **kwargs)
+        if not self.target.merged:
+            for (adapter_n, active_adapter) in enumerate(self.target.active_adapters):
+                if self.target.use_dora[active_adapter]:
+                    raise ValueError('X-LoRA currently does not support LoRA layers with DoRA')
+                if active_adapter not in self.target.lora_A.keys():
+                    continue
+                lora_A = self.target.lora_A[active_adapter]
+                lora_B = self.target.lora_B[active_adapter]
+                dropout = self.target.lora_dropout[active_adapter]
+                scaling = self.target.scaling[active_adapter]
+                x = x.to(lora_A.weight.dtype)
+                if scalings is not None:
+                    x_mod = self.apply_scalings_to_x(x, xlora_scalings, adapter_n)
+                    scaling_weight = self.config.global_scaling_weight
+                else:
+                    x_mod = x
+                    scaling_weight = 1
+                result += lora_B(lora_A(dropout(x_mod))) * scaling * scaling_weight
+        result = result.to(previous_dtype)
+        return result
+
+class XLoraEmbeddingLayer(XLoraLayer):
+
+    def __init__(self, model: nn.Module, target: lora.Embedding, target_forward: Callable[..., Any], layer_number: int, config: XLoraConfig) -> None:
+        super().__init__(model, target, target_forward, layer_number, config)
+
+    def forward(self, x: Tensor, *args: Any, scalings: Optional[Tensor]=None, **kwargs: Any) -> Tensor:
+        if scalings is not None:
+            xlora_scalings = self.get_maybe_topk_scalings(scalings)
+        result = self.target.base_layer(x, *args, **kwargs)
+        if not self.target.merged:
+            for (adapter_n, active_adapter) in enumerate(self.target.active_adapters):
+                if self.target.use_dora.get(active_adapter, False):
+                    raise ValueError('X-LoRA currently does not support LoRA layers with DoRA')
+                if active_adapter not in self.target.lora_embedding_A:
+                    continue
+                embedding_A = self.target.lora_embedding_A[active_adapter].T
+                embedding_B = self.target.lora_embedding_B[active_adapter].T
+                scaling = self.target.scaling[active_adapter]
+                after_A = self.target._embed(x, embedding_A)
+                if scalings is not None:
+                    after_A_mod = self.apply_scalings_to_x(after_A, xlora_scalings, adapter_n)
+                    scaling_weight = self.config.global_scaling_weight
+                else:
+                    after_A_mod = after_A
+                    scaling_weight = 1
+                result += after_A_mod @ embedding_B * scaling * scaling_weight
+        return result
+
+class XLoraConv2dLayer(XLoraLayer):
+
+    def __init__(self, model: nn.Module, target: lora.Conv2d, target_forward: Callable[..., Any], layer_number: int, config: XLoraConfig) -> None:
+        super().__init__(model, target, target_forward, layer_number, config)
+
+    def forward(self, x: Tensor, *args: Any, scalings: Optional[Tensor]=None, **kwargs: Any) -> Tensor:
+        previous_dtype = x.dtype
+        if scalings is not None:
+            xlora_scalings = self.get_maybe_topk_scalings(scalings)
+        result = self.target.base_layer(x, *args, **kwargs)
+        if not self.target.merged:
+            for (adapter_n, active_adapter) in enumerate(self.target.active_adapters):
+                if self.target.use_dora[active_adapter]:
+                    raise ValueError('X-LoRA currently does not support LoRA layers with DoRA')
+                if active_adapter not in self.target.lora_A.keys():
+                    continue
+                lora_A = self.target.lora_A[active_adapter]
+                lora_B = self.target.lora_B[active_adapter]
+                dropout = self.target.lora_dropout[active_adapter]
+                scaling = self.target.scaling[active_adapter]
+                x = x.to(lora_A.weight.dtype)
+                if scalings is not None:
+                    x_mod = self.apply_scalings_to_x(x, xlora_scalings, adapter_n)
+                    scaling_weight = self.config.global_scaling_weight
+                else:
+                    x_mod = x
+                    scaling_weight = 1
+                result += lora_B(lora_A(dropout(x_mod))) * scaling * scaling_weight
+        result = result.to(previous_dtype)
+        return result
+
+# File: peft-main/src/peft/tuners/xlora/model.py
+from __future__ import annotations
+import copy
+from contextlib import contextmanager
+from functools import partial
+from typing import Optional, Union
+import torch
+import torch.nn as nn
+from peft.tuners.lora.layer import LoraLayer
+from peft.tuners.lora.model import LoraModel
+from peft.tuners.tuners_utils import BaseTuner
+from peft.utils.constants import DUMMY_TARGET_MODULES
+from peft.utils.save_and_load import set_peft_model_state_dict
+from .. import lora
+from .classifier import XLoraClassifier
+from .config import XLoraConfig
+from .layer import XLoraConv2dLayer, XLoraEmbeddingLayer, XLoraLinearLayer
+
+def convert_layers_to_xlora(base: nn.Module, xloramodel: nn.Module, config: XLoraConfig) -> tuple[int, torch.device | None]:
+    total_swapped = 0
+    all_layers = []
+    device = None
+    for module in base.modules():
+        if isinstance(module, lora.Linear):
+            device = module.lora_A[next(iter(module.lora_A))].weight.device
+            new_layer = XLoraLinearLayer(model=xloramodel, target=module, target_forward=module.forward, layer_number=total_swapped, config=config)
+            all_layers.append(new_layer)
+            module.forward = new_layer.forward
+            total_swapped += 1
+        elif isinstance(module, lora.Embedding):
+            device = module.lora_embedding_A[next(iter(module.lora_embedding_A))].device
+            new_layer = XLoraEmbeddingLayer(model=xloramodel, target=module, target_forward=module.forward, layer_number=total_swapped, config=config)
+            all_layers.append(new_layer)
+            module.forward = new_layer.forward
+            total_swapped += 1
+        elif isinstance(module, lora.Conv2d):
+            device = module.lora_A[next(iter(module.lora_A))].weight.device
+            new_layer = XLoraConv2dLayer(model=xloramodel, target=module, target_forward=module.forward, layer_number=total_swapped, config=config)
+            all_layers.append(new_layer)
+            module.forward = new_layer.forward
+            total_swapped += 1
+    return (total_swapped, device)
+
+def _load_adapter_into_lora_model(lora_model: LoraModel, adapter_name: str, model_id: str, torch_device: Optional[str]=None, ephemeral_gpu_offload: bool=False, autocast_adapter_dtype: bool=True, subfolder: Optional[str]=None, **kwargs):
+    from peft.peft_model import PeftModel
+    from peft.tuners.lora.config import LoraConfig
+    from peft.utils.other import infer_device
+    from peft.utils.save_and_load import load_peft_weights
+    (hf_hub_download_kwargs, kwargs) = PeftModel._split_kwargs(kwargs)
+    if torch_device is None:
+        torch_device = infer_device()
+    if adapter_name not in lora_model.peft_config:
+        lora_peft_config = LoraConfig.from_pretrained(model_id, ephemeral_gpu_offload=ephemeral_gpu_offload, subfolder=subfolder, **hf_hub_download_kwargs)
+        lora_peft_config.inference_mode = False
+        lora_model.peft_config[adapter_name] = lora_peft_config
+        lora_model.inject_adapter(lora_model.model, adapter_name)
+    adapter_weights = load_peft_weights(model_id, device=torch_device, subfolder=subfolder, **hf_hub_download_kwargs)
+    new_adapter_weights = {}
+    for old_key in adapter_weights.keys():
+        key: str = old_key
+        while not (key.startswith('model.') and (not key.startswith('model.model.'))):
+            key = key[key.find('.') + 1:]
+        key = 'model.' + key
+        new_adapter_weights[key] = adapter_weights[old_key]
+    ignore_mismatched_sizes = kwargs.get('ignore_mismatched_sizes', False)
+    load_result = set_peft_model_state_dict(lora_model, new_adapter_weights, adapter_name=adapter_name, ignore_mismatched_sizes=ignore_mismatched_sizes)
+    if len(load_result.unexpected_keys) > 0:
+        raise ValueError(f'Got unexpected keys! Please raise an issue and tag @EricLBuehler.\n\nunexpected_keys={load_result.unexpected_keys}')
+    if hasattr(lora_model, '_cast_adapter_dtype'):
+        lora_model._cast_adapter_dtype(adapter_name=adapter_name, autocast_adapter_dtype=autocast_adapter_dtype)
+
+class XLoraModel(BaseTuner):
+
+    def __init__(self, model: nn.Module, config: Union[dict[str, XLoraConfig], XLoraConfig], adapter_name: str, torch_device: Optional[str]=None, ephemeral_gpu_offload: bool=False, autocast_adapter_dtype: bool=True, **kwargs) -> None:
+        nn.Module.__init__(self)
+        if isinstance(config, dict):
+            conf = config[adapter_name]
+        else:
+            conf = config
+        base_lora_config = copy.copy(conf)
+        base_lora_config.target_modules = DUMMY_TARGET_MODULES
+        base_lora_config.layer_replication = None
+        base_lora_config.bias = 'none'
+        lora_model = LoraModel(model, base_lora_config, adapter_name)
+        self.xlora_config = conf
+        self.lora_model = lora_model
+        peft_config = conf
+        if hasattr(model.config, 'use_cache') and model.config.use_cache:
+            raise ValueError('`use_cache` must be False')
+        adapters_items = peft_config.adapters.items()
+        if hasattr(self.xlora_config, '_subfolders'):
+            adapters_items = zip(peft_config.adapters.items(), self.xlora_config._subfolders)
+        else:
+            adapters_items = peft_config.adapters.items()
+        if hasattr(self.xlora_config, '_subfolders'):
+            for (i, (_adapter_name, model_id), subfolder) in enumerate(adapters_items):
+                _load_adapter_into_lora_model(lora_model=self.lora_model, adapter_name=str(i), model_id=model_id, torch_device=torch_device, ephemeral_gpu_offload=ephemeral_gpu_offload, autocast_adapter_dtype=autocast_adapter_dtype, subfolder=subfolder, **kwargs)
+        else:
+            for (i, (_adapter_name, model_id)) in enumerate(adapters_items):
+                _load_adapter_into_lora_model(lora_model=self.lora_model, adapter_name=str(i), model_id=model_id, torch_device=torch_device, ephemeral_gpu_offload=ephemeral_gpu_offload, autocast_adapter_dtype=autocast_adapter_dtype, subfolder=None, **kwargs)
+        self.lora_model.set_adapter(list(peft_config.adapters.keys()))
+        self._maybe_freeze_all_adapters()
+        (total_swapped, device) = convert_layers_to_xlora(model, self, peft_config)
+        n_classes = len(peft_config.adapters)
+        xlora_classifier = XLoraClassifier(model, peft_config, n_classes, total_swapped, device)
+        self.internal_xlora_classifier = xlora_classifier
+        self.internal_xlora_scalings = None
+        self.disabled = False
+
+    def _maybe_freeze_all_adapters(self):
+        self.eval()
+        if not self.xlora_config.use_trainable_adapters:
+            for (name, param) in self.named_parameters():
+                if 'lora_' in name:
+                    param.requires_grad = False
+
+    def generate(self, *args, **kwargs):
+        res = self.lora_model.generate(*args, **kwargs)
+        self._maybe_freeze_all_adapters()
+        return res
+
+    @contextmanager
+    def _enable_peft_forward_hooks(self, *generate_args, **generate_kwargs):
+
+        def scalings_injection_hook(target, args, kwargs, scalings):
+            kwargs['scalings'] = scalings
+            return (args, kwargs)
+        handles_to_remove = None
+
+        def pre_forward(module, *args, **kwargs):
+            nonlocal handles_to_remove
+            args_real = args[0]
+            kwargs_real = args[1]
+            kwargs_real.update(kwargs)
+            dummy_scalings = self.internal_xlora_classifier.make_dummy_scalings(*args_real, **kwargs_real)
+            hook_handles = []
+            for module in self.modules():
+                if isinstance(module, LoraLayer):
+                    pre_forward = partial(scalings_injection_hook, scalings=dummy_scalings)
+                    handle = module.register_forward_pre_hook(pre_forward, with_kwargs=True)
+                    hook_handles.append(handle)
+            with torch.no_grad():
+                self.lora_model.disable_adapter_layers()
+                try:
+                    scaling_pass_kwargs = kwargs_real.copy()
+                    scaling_pass_kwargs['output_hidden_states'] = True
+                    scaling_pass_kwargs['return_dict'] = True
+                    try:
+                        base_output = self.lora_model.model.forward(*args_real, **scaling_pass_kwargs)
+                    finally:
+                        for handle in hook_handles:
+                            handle.remove()
+                finally:
+                    self.lora_model.enable_adapter_layers()
+            xlora_scalings = self.internal_xlora_classifier(*args_real, result=base_output, **kwargs_real)
+            hook_handles = []
+            for module in self.modules():
+                if isinstance(module, LoraLayer):
+                    pre_forward = partial(scalings_injection_hook, scalings=xlora_scalings)
+                    handle = module.register_forward_pre_hook(pre_forward, with_kwargs=True)
+                    hook_handles.append(handle)
+            handles_to_remove = hook_handles
+        if not self.disabled:
+            forward_handle = self.lora_model.model.register_forward_pre_hook(pre_forward, with_kwargs=True)
+        yield
+        if not self.disabled:
+            for handle in handles_to_remove:
+                handle.remove()
+            forward_handle.remove()
+
+    def __getattr__(self, name: str):
+        try:
+            return super().__getattr__(name)
+        except AttributeError:
+            if name == 'lora_model':
+                raise
+            return getattr(self.lora_model, name)
+
+    @staticmethod
+    def _prepare_adapter_config(peft_config, _model_config):
+        return peft_config
+    ''
+
+    def _mark_only_adapters_as_trainable(self) -> None:
+        ...
+    ''
+
+    def enable_adapter_layers(self) -> None:
+        self.disabled = False
+    ''
+
+    def disable_adapter_layers(self) -> None:
+        self.disabled = True
+
+    def _create_and_replace(self, lora_config, adapter_name, target, target_name, parent, current_key):
+        pass
+
+    @staticmethod
+    def _check_target_module_exists(lora_config, key):
+        return False
+
+    def forward(self, *args, **kwargs):
+        return self.lora_model.model(*args, **kwargs)
+
+    def set_topk_lora(self, value: Optional[int]):
+        classifier: XLoraClassifier = self.internal_xlora_classifier
+        classifier.config.top_k_lora = value
+
+    def set_global_scaling_weight(self, weight: float):
+        classifier: XLoraClassifier = self.internal_xlora_classifier
+        classifier.config.global_scaling_weight = weight
+
+    def set_scaling_pass_value(self, value: float | None):
+        classifier: XLoraClassifier = self.internal_xlora_classifier
+        classifier._set_override_scaling_pass_value(value)
+
+    def get_global_scaling_weight(self) -> float:
+        classifier: XLoraClassifier = self.internal_xlora_classifier
+        return classifier.config.global_scaling_weight
+
+    def get_latest_scalings(self) -> Optional[torch.Tensor]:
+        return self.internal_xlora_scalings
+
+    def get_scalings_log(self) -> list[torch.Tensor]:
+        classifier: XLoraClassifier = self.internal_xlora_classifier
+        return classifier.log_scalings.copy()
+
+    def enable_scalings_logging(self):
+        classifier: XLoraClassifier = self.internal_xlora_classifier
+        classifier.scalings_logging = True
+
+    def disable_scalings_logging(self):
+        classifier: XLoraClassifier = self.internal_xlora_classifier
+        classifier.scalings_logging = False
+
+    def clear_scalings_log(self):
+        classifier: XLoraClassifier = self.internal_xlora_classifier
+        classifier.log_scalings.clear()
+
+    def get_bucketed_scalings_log(self) -> dict[int, tuple[list[int], list[torch.Tensor]]]:
+        classifier: XLoraClassifier = self.internal_xlora_classifier
+        return classifier._get_bucketed_scalings()
+