# Prefix tuning

    

Optimalkan parameter prefix untuk setiap tugas (sumber gambar).

[Prefix tuning](https://hf.co/papers/2101.00190) menambahkan serangkaian vektor spesifik tugas ke awal urutan input yang dapat dipelajari sambil mempertahankan model pra-terlatih tetap beku. Parameter prefix disisipkan ke dalam semua lapisan model.

Abstrak dari makalah tersebut adalah:

*Fine-tuning adalah cara de facto untuk memanfaatkan model bahasa pretrained berskala besar guna menjalankan tugas downstream. Namun, metode ini memodifikasi seluruh parameter model bahasa sehingga mengharuskan penyimpanan salinan lengkap untuk setiap tugas. Dalam makalah ini, kami mengusulkan prefix-tuning, alternatif ringan dari fine-tuning untuk tugas natural language generation, yang menjaga parameter model bahasa tetap beku, tetapi mengoptimalkan vektor tugas spesifik yang kecil dan kontinu (disebut prefix). Prefix-tuning terinspirasi dari prompting, memungkinkan token berikutnya untuk memperhatikan prefix ini seolah-olah prefix tersebut adalah "virtual tokens". Kami menerapkan prefix-tuning pada GPT-2 untuk table-to-text generation dan pada BART untuk summarization. Kami menemukan bahwa dengan hanya mempelajari 0,1\% dari parameter, prefix-tuning memperoleh kinerja yang sebanding dalam pengaturan data penuh, melampaui fine-tuning dalam pengaturan data rendah, dan melakukan ekstrapolasi yang lebih baik ke contoh dengan topik yang tidak terlihat selama pelatihan*.

**Catatan** Untuk model encoder-decoder (seq2seq), prefix hanya diterapkan pada decoder, yang tidak sesuai dengan spesifikasi paper (lihat misalnya Gambar 2). Prefix tuning masih dapat di-fine-tune pada arsitektur model ini, tetapi kinerjanya bisa kurang optimal; pertimbangkan untuk menggunakan metode PEFT lain untuk model encoder-decoder.

Prefix tuning sangat mirip dengan [prompt tuning](../package_reference/prompt_tuning). Perbedaan utamanya adalah bahwa parameter prefix disisipkan ke dalam **semua** lapisan model, sedangkan prompt tuning hanya menambahkan parameter prompt ke embedding input model. Parameter prefix juga dioptimalkan oleh jaringan feed-forward (FFN) yang terpisah, bukan dengan melatih langsung pada soft prompt, karena hal tersebut menyebabkan ketidakstabilan dan menurunkan kinerja. FFN dibuang setelah soft prompt diperbarui.

Sebagai hasilnya, para penulis menemukan bahwa prefix tuning menunjukkan kinerja yang setara dengan finetuning penuh pada sebuah model, meskipun memiliki 1000x lebih sedikit parameter, dan kinerjanya bahkan lebih baik dalam pengaturan data rendah.

## Penggunaan Dasar

Buat [PrefixTuningConfig](/docs/peft/main/id/package_reference/prefix_tuning#peft.PrefixTuningConfig) dengan tipe tugas dan jumlah token virtual yang akan ditambahkan dan dipelajari.

```py
from peft import PrefixTuningConfig, get_peft_model

peft_config = PrefixTuningConfig(task_type="CAUSAL_LM", num_virtual_tokens=20)
model = get_peft_model(model, peft_config)
model.print_healthcheck()
```

## Inisialisasi yang Mungkin

Secara default, prefix tuning menggunakan token virtual yang diinisialisasi secara acak. Ada juga opsi untuk menginisialisasi vektor agar mendekati no-op (jika diinisialisasi ke nol, hal itu masih akan menggeser massa probabilitas sedikit). Ini berarti bahwa prefix yang disuntikkan ke KV-cache memiliki dampak yang lebih kecil sejak awal dan mengurangi varians dalam kinerja pelatihan.

PEFT juga menyediakan utilitas untuk menginisialisasi adapter prefix-tuning dari prefix KV cache yang sudah ada (misalnya, dari `p` token pertama dari prompt/korpus). Ini hanya didukung ketika `prefix_projection=False` (default), karena dalam kasus tersebut parameter yang dipelajari adalah prefix KV itu sendiri.

```py
from transformers import AutoModelForCausalLM, AutoTokenizer

from peft import PrefixTuningConfig, get_peft_model, initialize_kv_prefix_from_text

base = AutoModelForCausalLM.from_pretrained("gpt2")
tok = AutoTokenizer.from_pretrained("gpt2")

peft_cfg = PrefixTuningConfig(task_type="CAUSAL_LM", num_virtual_tokens=20, prefix_projection=False)
model = get_peft_model(base, peft_cfg)

initialize_kv_prefix_from_text(
    model,
    tok,
    text="...a long context with at least num_virtual_tokens tokens...",
    use_chat_template=False,
)m peft import PrefixTuningConfig, get_peft_model, initialize_kv_prefix_from_text

base = AutoModelForCausalLM.from_pretrained("gpt2")
tok = AutoTokenizer.from_pretrained("gpt2")

peft_cfg = PrefixTuningConfig(task_type="CAUSAL_LM", num_virtual_tokens=20, prefix_projection=False)
model = get_peft_model(base, peft_cfg)

initialize_kv_prefix_from_text(
    model,
    tok,
    text="...a long context with at least num_virtual_tokens tokens...",
    use_chat_template=False,
)

```

Pastikan teks cukup panjang untuk menghasilkan setidaknya `num_virtual_tokens` token, jika tidak inisialisasi akan gagal.

Sebagai pedoman:

* mulai dengan urutan awal yang netral menggunakan `initialize_kv_prefix_from_text`, bisa berupa string yang sangat pendek seperti "Question: "
* jika itu tidak membantu, gunakan urutan yang lebih panjang dengan relevansi tugas (yaitu prompt yang direkayasa), yang memberi Anda lebih banyak token virtual untuk muat tetapi juga lebih banyak pengendalian model
* jika tidak memungkinkan untuk menggunakan teks inisialisasi atau Anda ingin dengan cepat memeriksa apakah prefix tuning layak digunakan, gunakan inisialisasi nol tanpa proyeksi

## Ikhtisar benchmark

<iframe src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=PREFIX_TUNING" frameborder="0" width="850" height="1000"
>

# API

## PrefixTuningConfig[[peft.PrefixTuningConfig]]

#### peft.PrefixTuningConfig[[peft.PrefixTuningConfig]]

```python
peft.PrefixTuningConfig(task_type: Optional[Union[str, TaskType]] = None, peft_type: Optional[Union[str, PeftType]] = None, auto_mapping: Optional[dict] = None, peft_version: Optional[str] = None, base_model_name_or_path: Optional[str] = None, revision: Optional[str] = None, inference_mode: bool = False, num_virtual_tokens: int = None, token_dim: int = None, num_transformer_submodules: Optional[int] = None, num_attention_heads: Optional[int] = None, num_layers: Optional[int] = None, modules_to_save: Optional[list[str]] = None, init_weights: typing.Literal['zero'] | None = None, encoder_hidden_size: int = None, prefix_projection: bool = False)
```

[Sumber](https://github.com/huggingface/peft/blob/main/src/peft/tuners/prefix_tuning/config.py#L23)

**Parameter:**

init_weights (`Optional[str]`) : Jika tidak diatur, bobot diinisialisasi secara acak. Jika diatur ke "zero", bobot diinisialisasi sehingga aktivasi akan menjadi no-op (nol).

encoder_hidden_size (`int`) : Ukuran tersembunyi dari pengkode prompt.

prefix_projection (`bool`) : Apakah akan memproyeksikan embedding prefix.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari [PrefixEncoder](/docs/peft/main/id/package_reference/prefix_tuning#peft.PrefixEncoder).

## PrefixEncoder[[peft.PrefixEncoder]]

#### peft.PrefixEncoder[[peft.PrefixEncoder]]

```python
peft.PrefixEncoder(config)
```

[Sumber](https://github.com/huggingface/peft/blob/main/src/peft/tuners/prefix_tuning/model.py#L22)

**Parameter:**

config ([PrefixTuningConfig](/docs/peft/main/id/package_reference/prefix_tuning#peft.PrefixTuningConfig)) : Konfigurasi dari encoder prefix.

Model `torch.nn` untuk mengodekan prefiks.

Contoh:

```py
>>> from peft import PrefixEncoder, PrefixTuningConfig

>>> config = PrefixTuningConfig(
...     peft_type="PREFIX_TUNING",
...     task_type="SEQ_2_SEQ_LM",
...     num_virtual_tokens=20,
...     token_dim=768,
...     num_transformer_submodules=1,
...     num_attention_heads=12,
...     num_layers=12,
...     encoder_hidden_size=768,
... )
>>> prefix_encoder = PrefixEncoder(config)
```

**Atribut**:
- **embedding** (`torch.nn.Embedding`) -- Lapisan embedding dari encoder prefix.
- **transform** (`torch.nn.Sequential`) -- MLP dua lapis untuk mentransformasi embedding prefix jika `prefix_projection` adalah `True`.
- **prefix_projection** (`bool`) -- Apakah akan memproyeksikan embedding prefix.

Bentuk input: (`batch_size`, `num_virtual_tokens`)

Bentuk output: (`batch_size`, `num_virtual_tokens`, `2*layers*hidden`)

#### load_prompt_embeddings[[peft.PrefixEncoder.load_prompt_embeddings]]

```python
load_prompt_embeddings(prompt_embeddings: Tensor)
```

[Sumber](https://github.com/huggingface/peft/blob/main/src/peft/tuners/prefix_tuning/model.py#L91)

Muat embedding prompt yang telah diratakan dan disimpan oleh PEFT (`prompt_embeddings`).

Untuk prefix tuning, ini hanya didukung ketika `prefix_projection=False`, karena dalam kasus tersebut parameter yang dipelajari adalah prefix KV itu sendiri (`embedding.weight` memiliki bentuk `[num_virtual_tokens, num_layers*2*token_dim]`).

Jika `prefix_projection=True`, parameternya adalah (embedding token virtual + MLP) dan tidak ada cara umum untuk membalikkan proyeksi guna memulihkan parameter tersebut dari prefix KV yang telah diratakan.

