# Prompt tuning

    

Treine e armazene apenas um conjunto significativamente menor de parâmetros de prompt específicos da tarefa (fonte da imagem).

[Prompt tuning](https://hf.co/papers/2104.08691) adiciona um prompt virtual específico da tarefa à entrada, composto por vetores treináveis no espaço de incorporação. Os parâmetros dos tokens virtuais são atualizados de forma independente dos parâmetros do modelo pré-treinado, que permanecem congelados.

O resumo do artigo é:

*Neste trabalho, exploramos o "prompt tuning", um mecanismo simples, porém eficaz, para aprender "soft prompts" que condicionam modelos de linguagem congelados a executar tarefas específicas de baixo nível. Diferentemente dos prompts de texto discretos usados pelo GPT-3, os soft prompts são aprendidos por retropropagação e podem ser ajustados para incorporar sinal de qualquer número de exemplos rotulados. Nossa abordagem de aprendizado de ponta a ponta supera o aprendizado "few-shot" do GPT-3 por uma grande margem. Mais notavelmente, por meio de ablações no tamanho do modelo usando T5, mostramos que o prompt tuning se torna mais competitivo com a escala: à medida que os modelos excedem bilhões de parâmetros, nosso método "fecha a lacuna" e iguala o forte desempenho do ajuste do modelo (onde todos os pesos do modelo são ajustados). Essa descoberta é especialmente relevante, pois modelos grandes são custosos para compartilhar e servir, e a capacidade de reutilizar um modelo congelado para múltiplas tarefas de baixo nível pode aliviar esse fardo. Nosso método pode ser visto como uma simplificação do "prefix tuning" recentemente proposto por Li e Liang (2021), e fornecemos uma comparação com essa e outras abordagens semelhantes. Finalmente, mostramos que condicionar um modelo congelado com soft prompts confere benefícios em robustez à transferência de domínio, em comparação com o ajuste completo do modelo*.

Em contraste com o [prefix tuning](../package_reference/prefix_tuning), apenas a entrada da primeira camada recebe os tokens virtuais.

## Uso

Há duas decisões a tomar: quantos tokens virtuais são adicionados à entrada do modelo (`num_virtual_tokens`) — isso definirá quantos parâmetros treináveis haverá — e como esses tokens são inicializados.

Crie um [PromptTuningConfig](/docs/peft/main/pt/package_reference/prompt_tuning#peft.PromptTuningConfig) com o tipo de tarefa, o texto inicial de prompt tuning para treinar o modelo, o número de tokens virtuais a serem adicionados e aprendidos e um tokenizer.

```py
from peft import PromptTuningConfig, PromptTuningInit, get_peft_model

prompt_tuning_init_text = "Classify if the tweet is a complaint or no complaint.\n"
peft_config = PromptTuningConfig(
    task_type="CAUSAL_LM",
    prompt_tuning_init=PromptTuningInit.TEXT,
    num_virtual_tokens=len(tokenizer(prompt_tuning_init_text)["input_ids"]),
    prompt_tuning_init_text=prompt_tuning_init_text,
    tokenizer_name_or_path="bigscience/bloomz-560m",
)
model = get_peft_model(model, peft_config)
model.print_healthcheck()
```

## Visão geral do benchmark

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

# API

## PromptTuningConfig[[peft.PromptTuningConfig]]

#### peft.PromptTuningConfig[[peft.PromptTuningConfig]]

```python
peft.PromptTuningConfig(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, prompt_tuning_init: peft.tuners.prompt_tuning.config.PromptTuningInit | str = <PromptTuningInit.RANDOM: 'RANDOM'>, prompt_tuning_init_text: str | None = None, tokenizer_name_or_path: str | None = None, tokenizer_kwargs: dict | None = None)
```

[Fonte](https://github.com/huggingface/peft/blob/main/src/peft/tuners/prompt_tuning/config.py#L30)

**Parâmetros:**

prompt_tuning_init (Union[`PromptTuningInit`, `str`]) : A inicialização do embedding do prompt. `TEXT` inicializará com o seu texto. `SAMPLE_VOCAB` inicializará com tokens amostrados aleatoriamente do vocabulário do modelo. `RANDOM` inicializará com tokens contínuos e suaves amostrados aleatoriamente (aviso: tokens suaves amostrados podem ficar fora da variedade de embeddings)

prompt_tuning_init_text (`str`, *opcional*) : O texto para inicializar o embedding do prompt. Usado apenas se `prompt_tuning_init` for `TEXT`.

tokenizer_name_or_path (`str`, *opcional*) : O nome ou caminho do tokenizer. Usado apenas se `prompt_tuning_init` for `TEXT`.

tokenizer_kwargs (`dict`, *opcional*) : Os argumentos de palavra-chave a serem passados para `AutoTokenizer.from_pretrained`. Usado apenas se `prompt_tuning_init` for `TEXT`.

Esta é a classe de configuração para armazenar a configuração de um [PromptEmbedding](/docs/peft/main/pt/package_reference/prompt_tuning#peft.PromptEmbedding).

## PromptEmbedding[[peft.PromptEmbedding]]

#### peft.PromptEmbedding[[peft.PromptEmbedding]]

```python
peft.PromptEmbedding(config, word_embeddings)
```

[Fonte](https://github.com/huggingface/peft/blob/main/src/peft/tuners/prompt_tuning/model.py#L25)

**Parâmetros:**

config ([PromptTuningConfig](/docs/peft/main/pt/package_reference/prompt_tuning#peft.PromptTuningConfig)) : A configuração do embedding de prompt.

word_embeddings (`torch.nn.Module`) : Os embeddings de palavras do modelo transformer base.

O modelo para codificar tokens virtuais em embeddings de prompt.

**Atributos**:
- **embedding** (`torch.nn.Embedding`) -- A camada de embedding do embedding do prompt.

Exemplo:

```py
>>> from peft import PromptEmbedding, PromptTuningConfig

>>> config = PromptTuningConfig(
...     peft_type="PROMPT_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,
...     prompt_tuning_init="TEXT",
...     prompt_tuning_init_text="Predict if sentiment of this review is positive, negative or neutral",
...     tokenizer_name_or_path="t5-base",
... )

>>> # t5_model.shared is the word embeddings of the base model
>>> prompt_embedding = PromptEmbedding(config, t5_model.shared)
```

Formato de Entrada: (`batch_size`, `total_virtual_tokens`)

Formato da Saída: (`batch_size`, `total_virtual_tokens`, `token_dim`)

