PEFT documentation
Prompt Tuning com Consciência de Contexto: Avançando o Aprendizado no Contexto com Métodos Adversariais
Prompt Tuning com Consciência de Contexto: Avançando o Aprendizado no Contexto com Métodos Adversariais

Context-Aware Prompt Tuning (CPT) foi projetado para aprimorar a classificação few-shot refinando apenas os embeddings de contexto. Essa abordagem combina ideias de In-Context Learning (ICL), Prompt Tuning (PT) e otimização adversarial, focando em tornar a adaptação do modelo tanto eficiente em parâmetros quanto eficaz. No CPT, apenas os embeddings de tokens de contexto específicos são otimizados, enquanto o restante do modelo permanece congelado. Para evitar overfitting e manter a estabilidade, o CPT usa perturbações controladas para limitar as alterações permitidas nos embeddings de contexto dentro de uma faixa definida. Além disso, para abordar o fenômeno do viés de recência — em que exemplos próximos ao final do contexto tendem a ser priorizados em relação aos anteriores —, o CPT aplica um fator de perda de decaimento.
O resumo do artigo é:
Modelos de Linguagem de Grande Escala (LLMs) podem realizar aprendizado few-shot usando abordagens baseadas em otimização ou In-Context Learning (ICL). Os métodos baseados em otimização frequentemente sofrem com overfitting, pois exigem a atualização de um grande número de parâmetros com dados limitados. Em contraste, o ICL evita o overfitting, mas geralmente apresenta desempenho inferior em comparação com os métodos baseados em otimização e é altamente sensível à seleção, à ordem e ao formato dos exemplos de demonstração. Para superar esses desafios, introduzimos o Context-aware Prompt Tuning (CPT), um método inspirado no ICL, no Prompt Tuning (PT) e em ataques adversariais. O CPT se baseia na estratégia do ICL de concatenar exemplos antes da entrada, estendendo-a ao incorporar aprendizado semelhante ao PT para refinar o embedding do contexto por meio de otimização iterativa, extraindo insights mais profundos dos exemplos de treinamento. Nossa abordagem modifica cuidadosamente tokens específicos do contexto, considerando a estrutura única dos exemplos dentro do contexto. Além de atualizar o contexto com otimização semelhante ao PT, o CPT se inspira em ataques adversariais, ajustando a entrada com base nos rótulos presentes no contexto, preservando o valor inerente dos dados fornecidos pelo usuário. Para garantir robustez e estabilidade durante a otimização, empregamos um algoritmo de descida de gradiente projetado, restringindo os embeddings dos tokens para permanecerem próximos de seus valores originais e salvaguardando a qualidade do contexto. Nosso método demonstrou precisão superior em várias tarefas de classificação usando diversos modelos de LLM, superando as linhas de base existentes e abordando eficazmente o desafio de overfitting no aprendizado few-shot.
Dê uma olhada em Example para um guia passo a passo sobre como treinar um modelo com CPT.
Princípio de Funcionamento
Context-aware Prompt Tuning é semelhante ao Prompt Tuning no sentido de que você pode usar um prompt de texto de sua escolha, mas tornar treináveis apenas os tokens desse prompt, graças a uma segunda matriz de incorporação de tokens aplicada exclusivamente aos tokens do prompt. Sempre que você consulta um modelo CPT, seu prompt “suave” será adicionado à incorporação da sua entrada normal. O CPT difere do Prompt Tuning no fato de que seu prompt suave agora pode ser contextualizado, marcando partes específicas para NÃO serem treinadas. A matriz de incorporação de tokens específica do CPT consiste em uma incorporação estática inicializada a partir da matriz de incorporação do modelo base e em valores delta específicos de token que são aprendíveis.
CPT é útil quando você tem um prompt com instruções junto com exemplos e ground-truth/labels. As instruções podem ser subótimas e, portanto, se beneficiam de serem otimizadas durante o treinamento (como no prompt tuning), mas os exemplos/labels que você incluiu no prompt não devem ser alterados. Isso pode ser garantido definindo explicitamente onde o prompting termina e os exemplos começam. O CPT também adiciona uma perda de token à perda padrão de previsão do próximo token do seu modelo para os exemplos no prompt, a fim de fazer uso ideal dos exemplos fornecidos.
O CPT usa cinco ids de tipo diferentes para marcar as diferentes seções no prompt:
- 0: separador: será completamente ignorado, útil para tokens de início/fim de frase
- 1: marcador de entrada: tokens que descrevem o prompt que marca todo o modelo do lado da entrada, incluindo informações adicionais
- 2: consulta de entrada: tokens que descrevem a entrada do usuário de um exemplo
- 3: marcador de saída: tokens que descrevem o início da saída esperada de um exemplo
- 4: label: tokens pertencentes ao rótulo do exemplo
Isso é muito abstrato, então aqui está um exemplo de um prompt de CPT e os identificadores de tipo correspondentes. Assumimos que cada palavra = 1 token para simplificar:
prompt_text = "Example 1: Input: 1+1 Answer: 2 Example 2: 1+3 Answer: 4"
token_ids = [15, 2, 11, 9, 1, 9, 11, 3, 11, 8, 9, 4, 2, 4, 9, 11, 3, 6, 8, 9, 10]
# BOS, Example 1 : Input : 1 + 1 Answer : 2 Example 2 : 1 + 3 Answer : 4
type_ids = [0, 1, 1, 1, 1, 1, 2, 2, 2, 3, 3, 4, 5, 5, 5, 6, 6, 6, 7, 7, 8]
# 1, 1, 1, 2, 2, 2, 3, 3, 4Os token_ids são o seu prompt codificado pelo tokenizer do modelo base e correspondem a ~CPTConfig.cpt_token_ids. Os type_ids são os ids de tipo de token do prompt, definindo as diferentes seções do prompt e correspondem a ~CPTConfig.cpt_tokens_type_mask.
Os ids individuais têm efeitos diferentes no processo de treinamento:
- 0: será completamente ignorado, não contribui para a perda e esses tokens não são treinados, útil para tokens que estão lá apenas por razões técnicas e que, de outra forma, aumentariam inutilmente o espaço de parâmetros (por exemplo, tokens EOS)
- 1 e 3: esses tokens são considerados para formatação e a norma máxima de seu delta de incorporação é controlada por
opt_projection_format_epsilon(). A norma controla a magnitude máxima na qual os deltas de incorporação aprendidos para esse tipo podem apontar. Normas mais altas significam um potencial maior de mudança de significado. - 2: esses tokens são considerados para a entrada de um exemplo e a norma máxima do delta de seus embeddings é controlada por
opt_projection_epsilon(). A norma controla a magnitude máxima na qual os embeddings delta aprendidos para esse tipo podem apontar. Normas mais altas significam um potencial maior de mudança de significado. - 4: Os tokens de rótulo do prompt são adicionados como alvos extras de previsão de próximo token à perda padrão nos seus dados de treinamento; todos os outros tokens de soft-prompt são mascarados da perda. Os embeddings de delta dos tokens de rótulo nunca são alterados para manter a semântica dos rótulos intacta.
Você pode ter notado que os números em type_ids para o segundo exemplo estão deslocados em 4. O CPT possui uma ponderação exponencial para a perda dos exemplos que você fornece no prompt, sendo o último exemplo o menos decaído e a perda do primeiro exemplo a mais decaída. Isso dá mais peso aos exemplos mais próximos da consulta de entrada real e é controlado por opt_loss_decay_factor() quando opt_weighted_loss_type() está definido como "decay". Ao deslocar os exemplos em 4, podemos enumerar os diferentes exemplos para que a perda possa atribuir ponderações de decaimento diferentes a cada exemplo.
Observe que cpt_tokens_type_mask descreve apenas o soft prompt em si. Durante o treinamento, passe também um tensor input_type_mask junto com cada lote, atribuindo ids de tipo aos tokens da sua entrada real (usando os ids 0-4, conforme acima, com tokens de padding ou de fim de frase marcados como 0). O CPT desloca automaticamente esses ids pelo número de exemplos no seu prompt, então você não precisa deslocá-los manualmente. Isso equivale a adicionar a entrada no final da sua lista de exemplos no prompt. Lembre-se de que os ids são interpretados módulo 4: deslocá-los por um múltiplo de 4 é inofensivo, mas qualquer outro deslocamento altera silenciosamente quais tokens contribuem para a perda. Se nenhum input_type_mask for passado, o CPT recorre ao cálculo da perda sobre toda a sequência de entrada, ou seja, assumindo o tipo 4 para todos os tokens de entrada.
Visão geral do benchmark
Ainda não existe um benchmark para este método. Sinta-se à vontade para contribuir com uma configuração de experimento, mas certifique-se de primeiro criar uma issue aqui.
API
CPTConfig
classe peft.CPTConfig
< source >( 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 = Falsenum_virtual_tokens: int = Nonetoken_dim: int = Nonenum_transformer_submodules: Optional[int] = Nonenum_attention_heads: Optional[int] = Nonenum_layers: Optional[int] = Nonemodules_to_save: Optional[list[str]] = Nonecpt_token_ids: list[int] | None = Nonecpt_mask: list[int] | None = Nonecpt_tokens_type_mask: list[int] | None = Noneopt_weighted_loss_type: typing.Literal['none', 'decay'] | None = 'none'opt_loss_decay_factor: float | None = 1.0opt_projection_epsilon: float | None = 0.1opt_projection_format_epsilon: float | None = 0.1tokenizer_name_or_path: str | None = None )
Classe de configuração CPT que estende PeftConfig para Context-aware Prompt Tuning (CPT).
Esta classe introduz parâmetros adicionais necessários para o CPT, como:
- Máscaras de tipos de token
- Inicialização do prompt tuning
- Ponderação da perda
- Configurações de projeção
Para mais detalhes, consulte o artigo: https://huggingface.co/papers/2410.17222
CPTEmbedding
CPTEmbedding é uma camada de incorporação personalizada projetada para Context-aware Prompt Tuning (CPT) no PEFT. Ela inicializa as incorporações, aplica projeções específicas do prompt e calcula a perda usando máscaras de rótulos.
calculate_loss
< source >( base_model_outputlabelscpt_type_maskconfig ) → ModelOutput
Parâmetros
- base_model_output (ModelOutput) — Saída do modelo base contendo logits.
- labels (torch.Tensor) — Rótulos de referência para os tokens de entrada.
- cpt_type_mask (torch.Tensor) — Máscara de tipo de token usada para filtrar os termos de perda válidos.
- config (Namespace) — Configuration object containing loss-related hyperparameters.
Retorna
ModelOutput
A saída do modelo base com a perda calculada.
Calcula a perda para modelos CPT com decaimento exponencial opcional.
Em vez de calcular uma perda de entropia cruzada média uniforme em toda a sequência, esta função isola os tokens de rótulo para cada demonstração distinta usando o namespace modulo-4 codificado em cpt_type_mask. Com config.opt_weighted_loss_type="decay", aplica ponderação com decaimento exponencial (config.opt_loss_decay_factor) entre as demonstrações, priorizando os exemplos posteriores (e a previsão final da consulta) em relação às demonstrações anteriores.
Lógica de Agrupamento de Demonstrações:
- Tokens em que
(cpt_type_mask > 0) & (cpt_type_mask % 4 == 0)representam os rótulos de ground-truth. - O índice de demonstração
ké o rank do ID do tipo de rótulo entre os IDs de rótulo distintos presentes após o deslocamento do próximo token, em ordem ascendente (índice 0). - A perda de entropia cruzada é calculada para cada token de rótulo válido.
- Dado
KIDs de rótulos distintos e o fator de decaimentogamma(opt_loss_decay_factor), o peso para a demonstraçãok(onde0 <= k < K) é dado por:weight_k = gamma ** (K - 1 - k)A perda final é a soma das perdas de tokens ponderadas dividida pelo número de rótulos válidos.
Exemplo: Suponha que uma sequência contenha 2 demonstrações de prompt seguidas por 1 consulta do usuário (K = 3), cada uma com um rótulo válido após o deslocamento do próximo token:
- Demonstração 1 (Demonstração de prefixo 1): Os tokens de rótulo têm o tipo 4 -> Entropia cruzada L_0 = 2.0
- Demonstração 2 (Demonstração de prefixo 2): Os tokens de rótulo têm tipo 8 -> Entropia cruzada L_1 = 1.6
- Demonstração 3 (Consulta de destino): Os rótulos dos tokens têm o tipo 12 -> Entropia cruzada L_2 = 1.0
Com opt_weighted_loss_type="decay" e opt_loss_decay_factor = 0.5:
- Peso da Demonstração 1: 0.5 (3 - 1 - 0) = 0.5 2 = 0.25
- Peso da Demonstração 2: 0.5 (3 - 1 - 1) = 0.5 1 = 0.50
- Peso da Demonstração 3: 0.5 (3 - 1 - 2) = 0.5 0 = 1.00
Perda Ponderada: loss = (0.25 2.0 + 0.50 1.6 + 1.00 * 1.0) / 3 = (0.5 + 0.8 + 1.0) / 3 = 2.3 / 3 = 0.7666…
forward
< source >( indices ) → torch.Tensor
Calcula os embeddings do prompt e aplica os ajustes de delta.
Aplica a projeção baseada em epsilon aos embeddings delta para controlar sua norma.
Configura um hook de retropropagação para atualizar seletivamente os gradientes dos tokens com base na máscara do tipo de token do CPT.