PEFT documentation

X-LoRA

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

and get access to the augmented documentation experience

to get started

X-LoRA

Mixture of LoRA Experts (X-LoRA) adalah metode PEFT yang memungkinkan campuran LoRA experts secara sparse atau dense berdasarkan matriks penskalaan dengan granularitas tinggi (token, layer, sequence). Metode ini memanfaatkan adapter LoRA yang dibekukan dan model dasar yang dibekukan untuk secara drastis mengurangi jumlah parameter yang perlu dihaluskan.

Aspek unik dari X-LoRA adalah versatilitasnya: dapat diterapkan pada model dasar transformers mana pun dengan adapter LoRA. Artinya, meskipun menggunakan strategi mixture of experts, tidak perlu dilakukan perubahan pada kode model.

Grafik di bawah ini menunjukkan bagaimana penskalaan berubah untuk prompt yang berbeda pada setiap token. Hal ini menyoroti aktivasi adapter yang berbeda seiring kemajuan generasi dan pembentukan konteks baru oleh urutan.

Token-by-token scalings

Untuk setiap langkah, X-LoRA memerlukan model dasar untuk dijalankan dua kali: pertama, untuk mendapatkan hidden states tanpa adapter LoRA apa pun, dan kedua, hidden states tersebut digunakan untuk menghitung scalings yang diterapkan pada adapter LoRA, kemudian model dijalankan untuk kedua kalinya. Hasil dari eksekusi kedua adalah hasil dari langkah model.

Pada akhirnya, X-LoRA memungkinkan model untuk merefleksikan pengetahuannya berkat skema dual forward pass, serta secara dinamis mengonfigurasi ulang arsitekturnya.

Abstrak dari makalah tersebut adalah:

Kami melaporkan strategi campuran pakar untuk membuat model bahasa besar yang telah disempurnakan menggunakan pendekatan token per lapisan dalam yang berbasis pada adaptasi peringkat rendah (LoRA). Dimulai dari seperangkat adapter LoRA yang telah dilatih sebelumnya, strategi gating kami menggunakan keadaan tersembunyi untuk mencampur lapisan yang telah diadaptasi secara dinamis, memungkinkan model X-LoRA yang dihasilkan untuk memanfaatkan berbagai kemampuan dan menciptakan kombinasi lapisan dalam yang belum pernah digunakan sebelumnya untuk menyelesaikan tugas. Desain ini terinspirasi oleh prinsip biologi universalitas dan keberagaman, di mana blok bangunan jaringan saraf digunakan kembali dalam manifestasi hierarkis yang berbeda. Oleh karena itu, model X-LoRA dapat dengan mudah diimplementasikan untuk model bahasa besar (LLM) yang sudah ada tanpa perlu modifikasi pada struktur dasarnya. Kami mengembangkan model X-LoRA yang disesuaikan yang menawarkan kemampuan ilmiah termasuk tugas analisis maju/balik dan kemampuan penalaran yang ditingkatkan, dengan fokus pada analisis biomaterial, mekanika dan desain protein. Dampak dari pekerjaan ini termasuk akses ke model yang mudah diperluas dan diadaptasi dengan pengetahuan domain yang kuat serta kemampuan untuk terintegrasi di berbagai bidang pengetahuan. Dengan menghadirkan pakar di bidang biologi, matematika, penalaran, material bio-terinspirasi, mekanika dan material, kimia, biofisika protein, mekanika, dan sifat molekuler berbasis mekanika kuantum, kami melakukan serangkaian studi kasus yang berfokus pada fisika. Kami memeriksa pengingatan pengetahuan, tugas maju/balik mekanika protein, desain protein, pemodelan agen adversarial termasuk konstruksi graf pengetahuan ontologis, serta desain molekuler. Model ini mampu tidak hanya membuat prediksi kuantitatif tentang sifat nanomekanik protein atau sifat molekuler mekanika kuantum, tetapi juga menalar hasil tersebut dan dengan benar memprediksi mekanisme yang mungkin menjelaskan perilaku molekuler yang berbeda..

Silakan sitasi X-LoRA sebagai:

@article{10.1063/5.0203126,
    author = {Buehler, Eric L. and Buehler, Markus J.},
    title = "{X-LoRA: Mixture of low-rank adapter experts, a flexible framework for large language models with applications in protein mechanics and molecular design}",
    journal = {APL Machine Learning},
    volume = {2},
    number = {2},
    pages = {026119},
    year = {2024},
    month = {05},
    abstract = "{We report a mixture of expert strategy to create fine-tuned large language models using a deep layer-wise token-level approach based on low-rank adaptation (LoRA). Starting with a set of pre-trained LoRA adapters, our gating strategy uses the hidden states to dynamically mix adapted layers, allowing the resulting X-LoRA model to draw upon different capabilities and create never-before-used deep layer-wise combinations to solve tasks. The design is inspired by the biological principles of universality and diversity, where neural network building blocks are reused in different hierarchical manifestations. Hence, the X-LoRA model can be easily implemented for any existing large language model without a need for modifications of the underlying structure. We develop a tailored X-LoRA model that offers scientific capabilities, including forward/inverse analysis tasks and enhanced reasoning capability, focused on biomaterial analysis, protein mechanics, and design. The impact of this work includes access to readily expandable and adaptable models with strong domain knowledge and the capability to integrate across areas of knowledge. Featuring experts in biology, mathematics, reasoning, bio-inspired materials, mechanics and materials, chemistry, protein biophysics, mechanics, and quantum-mechanics based molecular properties, we conduct a series of physics-focused case studies. We examine knowledge recall, protein mechanics forward/inverse tasks, protein design, adversarial agentic modeling including ontological knowledge graph construction, and molecular design. The model is capable not only of making quantitative predictions of nanomechanical properties of proteins or quantum mechanical molecular properties but also reasoning over the results and correctly predicting likely mechanisms that explain distinct molecular behaviors.}",
    issn = {2770-9019},
    doi = {10.1063/5.0203126},
    url = {https://doi.org/10.1063/5.0203126},
    eprint = {https://pubs.aip.org/aip/aml/article-pdf/doi/10.1063/5.0203126/19964043/026119\_1\_5.0203126.pdf},
}

API

XLoraConfig

kelas peft.XLoraConfig

< >

( task_type: Optional[Union[str, TaskType]] = Nonepeft_type: Optional[Union[str, PeftType]] = Noneauto_mapping: Optional[dict] = Nonepeft_version: Optional[str] = Nonebase_model_name_or_path: Optional[str] = Nonerevision: Optional[str] = Noneinference_mode: bool = Falsehidden_size: int = Noneadapters: dict[str, str] = Noneenable_softmax: bool = Trueenable_softmax_topk: bool = Falselayerwise_scalings: bool = Falsexlora_depth: int = 1xlora_size: int = 2048xlora_dropout_p: float = 0.2use_trainable_adapters: bool = Falsesoftmax_temperature: float = 1.0top_k_lora: Optional[int] = Nonescaling_pass_value: float = 0.0global_scaling_weight: float = 1.0 )

Parameter

  • hidden_size (int) β€” Ukuran tersembunyi dari model dasar.
  • adapters (dict) β€” Pemetaan nama adapter ke id adapter LoRA, sesuai dengan PeftModel.load_adapter. Mereka akan dimuat secara otomatis, untuk digunakan sebagai pakar LoRA. Saat menggunakan from_pretrained, berikan dict adapter baru sebagai argumen kata kunci.
  • enable_softmax (bool, opsional, default True) β€” Aktifkan penerapan softmax untuk klasifikator X-LoRA.
  • enable_softmax_topk (bool, opsional, default False) β€” Aktifkan penerapan softmax untuk adapter LoRA top-k. Saling eksklusif dengan enable_softmax dan hanya boleh diatur jika top_k_lora diatur.
  • softmax_temperature (float, opsional, default 1.0) β€” Suhu softmax, nilai yang lebih rendah menghasilkan prediksi yang lebih tajam
  • layerwise_scalings (bool, opsional, default False) β€” Jika True, generate scalings untuk setiap adapter LoRA (setiap layer). Jika ini False, maka scalings akan di-broadcast, sama, ke setiap layer.
  • top_k_lora (int, opsional, defaultnya None) β€” Pilih secara sparsis top_k pakar LoRA alih-alih metode dense default.
  • xlora_depth (int, opsional, default 1) β€” Kedalaman klasifikator X-LoRA.
  • xlora_size (int, opsional, default 2048) β€” Ukuran tersembunyi dari klasifikator X-LoRA, tidak relevan jika xlora_depth=1.
  • xlora_dropout_p (float, opsional, default 0.2) β€” Probabilitas dropout dari klasifikator X-LoRA, tidak relevan jika xlora_depth=1.
  • use_trainable_adapters (bool, opsional, default False) β€” Jadikan adapter dapat dilatih.
  • scaling_pass_value (float, opsional, default 0) β€” Nilai pass scaling.
  • global_scaling_weight (float, opsional, default 1) β€” Bobot untuk mengalikan output dari setiap adapter LoRA.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari XLoraModel. Saat konfigurasi dimuat ulang, path dari field adapters diabaikan demi adapter yang disimpan. Dengan demikian, hanya key yang penting saat pemuatan.

XLoraModel

kelas peft.XLoraModel

< >

( model: nn.Moduleconfig: Union[dict[str, XLoraConfig], XLoraConfig]adapter_name: strtorch_device: Optional[str] = Noneephemeral_gpu_offload: bool = Falseautocast_adapter_dtype: bool = True**kwargs ) β†’ torch.nn.Module

Parameter

  • model (torch.nn.Module) β€” Model yang akan diadaptasi.
  • config (XLoraConfig) β€” Konfigurasi model Lora.
  • adapter_name (str) β€” Nama adapter, tidak memengaruhi nama adapter LoRA.

Mengembalikan

torch.nn.Module

Model X-LoRA.

Membuat model X-LoRA (Mixture of LoRA experts) dari model transformers yang sudah dilatih sebelumnya. Saat ini, implementasi X-LoRA ini hanya berfungsi dengan model yang memiliki arsitektur transformer.

Metode ini dijelaskan secara rinci di https://huggingface.co/papers/2402.07148.

Contoh:

>>> import torch
>>> from transformers import AutoModelForCausalLM, AutoConfig, BitsAndBytesConfig
>>> from peft import XLoraConfig, get_peft_model, prepare_model_for_kbit_training

>>> model_config = AutoConfig.from_pretrained("mistralai/Mistral-7B-Instruct-v0.1")
>>> config = XLoraConfig(
...     task_type="CAUSAL_LM",
...     hidden_size=model_config.hidden_size,
...     xlora_depth=4,
...     adapters={
...         "adapter_1": "./path/to/the/checkpoint/",
...         "adapter_2": "./path/to/the/checkpoint/",
...         "adapter_n": "./path/to/the/checkpoint/",
...     },
... )
>>> int8_config = BitsAndBytesConfig(load_in_8bit=True)
>>> model = AutoModelForCausalLM.from_pretrained(
...     "mistralai/Mistral-7B-Instruct-v0.1",
...     trust_remote_code=True,
...     attn_implementation="flash_attention_2",
...     device_map="cuda:0",
...     torch_dtype=torch.bfloat16,
...     quantization_config=int8_config,
... )
>>> model = prepare_model_for_kbit_training(model)
>>> xlora_model = get_peft_model(model, config)

clear_scalings_log

< >

( )

Hapus log skalasi.

disable_scalings_logging

< >

( )

Nonaktifkan pencatatan penskalaan, tanpa menghapus log.

enable_scalings_logging

< >

( )

Aktifkan pencatatan penskalaan.

get_bucketed_scalings_log

< >

( )

Mengembalikan penskalaan yang dikelompokkan, dikelompokkan berdasarkan seq_len. Setiap nilai terdiri dari posisi (yang pertama) dan tensor terkait. Posisi dipasangkan dengan tensor terkait dan memberikan posisi dalam log penskalaan.

get_global_scaling_weight

< >

( )

Dapatkan bobot LoRA global.

get_latest_scalings

< >

( )

Mengembalikan prediksi scalings terbaru, atau None jika tidak ada scalings yang diprediksi. Tensor memiliki bentuk (batch_size, seq_len, n_layers, n_classes).

get_scalings_log

< >

( )

Mengembalikan salinan dangkal (hanya menyalin daftar itu sendiri, bukan tensor) dari daftar yang berisi log penskalaan. Mengedit daftar tidak mengubah log yang mendasarinya. Tensor memiliki bentuk (batch_size, seq_len, n_layers, n_classes). Dimensi seq_len dapat bervariasi sesuai dengan dimensi input.

set_global_scaling_weight

< >

( weight: float )

Atur bobot LoRA global, yaitu skalar untuk mengalikan output dari setiap adapter LoRA. Secara default, nilainya adalah 1. Hal ini tercermin dalam konfigurasi.

set_scaling_pass_value

< >

( value: float | None )

Setel nilai pass penskalaan, yaitu nilai yang akan disetel untuk penskalaan selama pass penskalaan. Jika nilainya None, nilai pass penskalaan akan menjadi 1/n di mana n adalah jumlah adapter.

set_topk_lora

< >

( value: Optional[int] )

Pilih secara jarang top_k pakar LoRA yang ditentukan alih-alih metode dense default. Atur ke None untuk menggunakan dense. Hal ini tercermin dalam config.

Update on GitHub