# Контекстно-зависимая настройка промптов: развитие обучения в контексте с помощью противоречивых методов

    

CPT с оптимизацией только конкретных эмбеддингов токенов при заморозке остальной части модели (источник изображения).

[Context-Aware Prompt Tuning (CPT)](https://huggingface.co/papers/2410.17222) предназначен для улучшения классификации в режиме few-shot за счёт уточнения только контекстных эмбеддингов. Этот подход объединяет идеи из In-Context Learning (ICL), [Prompt Tuning](../package_reference/prompt_tuning) (PT) и противоречивой оптимизации, фокусируясь на том, чтобы сделать адаптацию модели одновременно параметрически эффективной и результативной. В CPT оптимизируются только эмбеддинги специфических контекстных токенов, тогда как остальная часть модели остаётся замороженной. Чтобы предотвратить переобучение и сохранить стабильность, CPT использует контролируемые возмущения, ограничивая допустимые изменения контекстных эмбеддингов в заданном диапазоне. Кроме того, для решения проблемы предвзятости к недавним примерам (recency bias) — когда примеры, расположенные ближе к концу контекста, получают приоритет над более ранними, — CPT применяет коэффициент затухания потерь.

Аннотация из статьи:

> Большие языковые модели (LLMs) способны выполнять обучение с малым количеством примеров (few-shot learning), используя либо методы на основе оптимизации, либо обучение в контексте (In-Context Learning, ICL). Методы на основе оптимизации часто страдают от переобучения, поскольку требуют обновления большого числа параметров при ограниченных данных. В отличие от них, ICL избегает переобучения, но, как правило, уступает по эффективности методам на основе оптимизации и крайне чувствителен к выбору, порядку и формату демонстрационных примеров. Чтобы преодолеть эти трудности, мы предлагаем метод контекстно-зависимой настройки промптов (Context-aware Prompt Tuning, CPT), вдохновленный ICL, настройкой промптов (Prompt Tuning, PT) и атаками на основе антагонистических примеров. CPT строится на стратегии ICL, заключающейся в конкатенации примеров перед входными данными, и расширяет ее, включая обучение в стиле PT для уточнения контекстного эмбеддинга посредством итеративной оптимизации, что позволяет извлекать более глубокие сведения из обучающих примеров. Наш подход тщательно модифицирует определенные токены контекста, учитывая уникальную структуру примеров внутри контекста. Помимо обновления контекста с помощью оптимизации в стиле PT, CPT черпает вдохновение в атаках на основе антагонистических примеров, корректируя входные данные на основе меток, присутствующих в контексте, при этом сохраняя внутреннюю ценность данных, предоставленных пользователем. Для обеспечения робастности и стабильности в процессе оптимизации мы применяем алгоритм проекционного градиентного спуска, ограничивая эмбеддинги токенов так, чтобы они оставались близкими к своим исходным значениям, что защищает качество контекста. Наш метод продемонстрировал более высокую точность на нескольких задачах классификации с использованием различных моделей LLM, превзойдя существующие базовые методы и эффективно решив проблему переобучения при обучении с малым количеством примеров.

Ознакомьтесь с [примером](https://github.com/huggingface/peft/blob/main/examples/cpt_finetuning/README.md), где пошагово описано, как обучить модель с помощью CPT.

## Принцип работы

Context-aware Prompt Tuning похож на [Prompt Tuning](./prompt_tuning) тем, что вы можете использовать текстовый промпт на свой выбор, но сделать обучаемыми токены именно этого промпта (и только его) за счёт наличия второй матрицы эмбеддингов токенов, применяемой исключительно к токенам промпта. При каждом запросе к модели CPT ваш «мягкий» промпт добавляется в начало эмбеддинга вашего обычного входного текста. Отличие CPT от Prompt Tuning состоит в том, что теперь ваш мягкий промпт может быть контекстуализирован путём пометки конкретных частей как необучаемых. Специфичная для CPT матрица эмбеддингов токенов состоит из статического эмбеддинга, инициализированного из матрицы эмбеддингов базовой модели, и обучаемых дельта-значений, специфичных для каждого токена.

CPT полезен, когда у вас есть промпт с инструкциями, примерами и эталонными данными/метками. Инструкции могут быть неоптимальными и, следовательно, выигрывают от оптимизации в процессе обучения (как при prompt tuning), но примеры/метки, включённые в промпт, не должны изменяться. Это можно обеспечить, явно определив, где заканчивается промптинг и начинаются примеры. CPT также добавляет потерю токенов к стандартной потере предсказания следующего токена вашей модели для примеров в промпте, чтобы максимально эффективно использовать предоставленные примеры.

CPT использует пять различных идентификаторов типов для разметки разных разделов в промпте:

* 0: separator: полностью игнорируется, полезно для токенов начала/конца предложения
* 1: маркер входа: токены, описывающие подсказку, которая обозначает весь шаблон входной стороны, включая дополнительную информацию
* 2: входной запрос: токены, описывающие пользовательский ввод примера
* 3: маркер вывода: токены, описывающие начало ожидаемого вывода примера
* 4: label: токены, относящиеся к метке примера

Это довольно абстрактно, поэтому ниже приведён пример промпта CPT и соответствующие идентификаторы типов. Для простоты предположим, что каждое слово = 1 токен:

```
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,  4
```

`token_ids` — это ваш промпт, закодированный токенизатором базовой модели, и он соответствует `~CPTConfig.cpt_token_ids`. `type_ids` — это идентификаторы типов токенов промпта, определяющие различные разделы промпта, и они соответствуют `~CPTConfig.cpt_tokens_type_mask`.

Каждый из идентификаторов оказывает различное влияние на процесс обучения:

* 0: полностью игнорируется, не вносит вклад в функцию потерь, и эти токены не обучаются; полезно для токенов, которые присутствуют исключительно по техническим причинам и в противном случае бесполезно расширяли бы пространство параметров (например, токены EOS)
* 1 и 3: эти токены учитываются при форматировании, а максимальная норма их дельта-эмбеддингов контролируется функцией `opt_projection_format_epsilon()`. Норма определяет максимальную величину, в пределах которой обученные дельта-эмбеддинги данного типа могут быть направлены. Чем выше норма, тем выше потенциальное изменение смысла.
* 2: эти токены учитываются при вводе примера, а максимальная норма их дельта-эмбеддингов контролируется функцией `opt_projection_epsilon()`. Норма определяет максимальную величину, в пределах которой обученные дельта-эмбеддинги данного типа могут быть направлены. Чем выше норма, тем выше потенциальное изменение смысла.
* 4: Токены меток из промпта добавляются в качестве дополнительных целей предсказания следующего токена к стандартной функции потерь на обучающих данных; все остальные токены мягкого промпта маскируются в функции потерь. Дельта-эмбеддинги токенов меток никогда не изменяются, чтобы сохранить семантику меток.

Вы могли заметить, что числа в `type_ids` для второго примера сдвинуты на 4. CPT использует экспоненциальное взвешивание для потерь примеров, которые вы предоставляете в промпте: последний пример имеет наименьшее затухание, а потеря первого примера затухает сильнее всего. Это придаёт больший вес примерам, расположенным ближе к фактическому входному запросу, и управляется параметром `opt_loss_decay_factor()`, когда `opt_weighted_loss_type()` установлено в значение `"decay"`. Сдвигая примеры на 4, мы можем пронумеровать различные примеры так, чтобы функция потерь могла назначать каждому из них различные веса затухания.

Обратите внимание, что `cpt_tokens_type_mask` описывает только сам мягкий промпт. Во время обучения дополнительно передавайте тензор `input_type_mask` вместе с каждой партией, назначая идентификаторы типов токенам вашего фактического входа (используя идентификаторы 0–4, как описано выше, при этом токены отступов или конца предложения помечаются как 0). CPT автоматически сдвигает эти идентификаторы на количество примеров в вашем промпте, поэтому вам не нужно выполнять сдвиг самостоятельно. Это эквивалентно добавлению входа в конец списка примеров в промпте. Помните, что идентификаторы интерпретируются по модулю 4: сдвиг на кратное 4 безвреден, но любое другое смещение незаметно меняет то, какие токены вносят вклад в функцию потерь. Если `input_type_mask` не передается, CPT переходит к вычислению потерь по всей входной последовательности, то есть предполагает тип 4 для всех входных токенов.

## Обзор бенчмарков

На данный момент для этого метода нет бенчмарка. Вы можете внести свой вклад, предоставив конфигурацию эксперимента, но сначала создайте задачу [здесь](https://github.com/huggingface/peft/issues).

# API

## CPTConfig[[peft.CPTConfig]]

#### peft.CPTConfig[[peft.CPTConfig]]

```python
peft.CPTConfig(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, cpt_token_ids: list[int] | None = None, cpt_mask: list[int] | None = None, cpt_tokens_type_mask: list[int] | None = None, opt_weighted_loss_type: typing.Literal['none', 'decay'] | None = 'none', opt_loss_decay_factor: float | None = 1.0, opt_projection_epsilon: float | None = 0.1, opt_projection_format_epsilon: float | None = 0.1, tokenizer_name_or_path: str | None = None)
```

[Источник](https://github.com/huggingface/peft/blob/v0.22.0/src/peft/tuners/cpt/config.py#L23)

Класс конфигурации CPT, расширяющий PeftConfig для контекстно-зависимой настройки промптов (CPT).

Этот класс вводит дополнительные параметры, необходимые для CPT, такие как:
- Маски типов токенов
- Инициализация prompt tuning
- Взвешивание потерь
- Настройки проекции

Подробнее в статье: https://huggingface.co/papers/2410.17222

## CPTEmbedding[[peft.CPTEmbedding]]

#### peft.CPTEmbedding[[peft.CPTEmbedding]]

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

[Источник](https://github.com/huggingface/peft/blob/v0.22.0/src/peft/tuners/cpt/model.py#L24)

CPTEmbedding — это собственный слой эмбеддингов, разработанный для Context-aware Prompt Tuning (CPT) в PEFT. Он инициализирует эмбеддинги, применяет проекции, специфичные для промптов, и вычисляет потерю с использованием масок меток.

#### calculate_loss[[peft.CPTEmbedding.calculate_loss]]

```python
calculate_loss(base_model_output, labels, cpt_type_mask, config)
```

[Источник](https://github.com/huggingface/peft/blob/v0.22.0/src/peft/tuners/cpt/model.py#L144)

**Параметры:**

base_model_output (ModelOutput) : Выходные данные базовой модели, содержащие логиты.

labels (torch.Tensor) : Истинные метки для входных токенов.

cpt_type_mask (torch.Tensor) : Маска типов токенов, используемая для фильтрации валидных членов функции потерь.

config (Пространство имён) : объект конфигурации, содержащий гиперпараметры, связанные с функцией потерь.

**Возвращает:** `ModelOutput`

Выход базовой модели с вычисленной потерей.

Вычисляет потерю для моделей CPT с необязательным экспоненциальным затуханием.

Вместо вычисления усреднённого кросс-энтропийного потерь по всей последовательности эта функция выделяет токены меток для каждой отдельной демонстрации, используя пространство имён с модулем 4, закодированное в `cpt_type_mask`. При `config.opt_weighted_loss_type="decay"` применяется взвешивание с экспоненциальным затуханием (`config.opt_loss_decay_factor`) по демонстрациям, что повышает приоритет более поздних примеров (и финального предсказания запроса) по сравнению с ранними демонстрациями.

Логика группировки демонстраций:
* Токены, для которых `(cpt_type_mask > 0) & (cpt_type_mask % 4 == 0)`, представляют собой эталонные метки.
* Индекс демонстрации `k` — это ранг идентификатора типа метки среди различных идентификаторов меток, присутствующих после сдвига на следующий токен, в порядке возрастания (индексация с нуля).
* Потеря кросс-энтропии вычисляется для каждого валидного токена метки.
* При `K` различных идентификаторах меток и коэффициенте затухания `gamma` (`opt_loss_decay_factor`) вес для демонстрации `k` (где `0 <= k < K`) вычисляется по формуле: `weight_k = gamma ** (K - 1 - k)` Итоговая функция потерь представляет собой сумму взвешенных потерь токенов, делённую на количество валидных меток.

Пример: допустим, последовательность содержит 2 демонстрации в промпте, за которыми следует 1 запрос пользователя (K = 3), и у каждого из них есть одна валидная метка после сдвига на следующий токен:
- Демо 1 (Префикс Демо 1): Токены меток имеют тип 4 -> Кросс-энтропия L_0 = 2.0
- Демо 2 (Префикс Демо 2): Токены меток имеют тип 8 -> Кросс-энтропия L_1 = 1.6
- Демо 3 (целевой запрос): токены меток имеют тип 12 -> Кросс-энтропия L_2 = 1.0

При `opt_weighted_loss_type="decay"` и `opt_loss_decay_factor = 0.5`:
- Демо 1 вес: 0.5 ** (3 - 1 - 0) = 0.5 ** 2 = 0.25
- Вес для демо 2: 0.5 ** (3 - 1 - 1) = 0.5 ** 1 = 0.50
- Вес для Demo 3: 0.5 ** (3 - 1 - 2) = 0.5 ** 0 = 1.00

Взвешенная потеря: 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[[peft.CPTEmbedding.forward]]

```python
forward(indices)
```

[Источник](https://github.com/huggingface/peft/blob/v0.22.0/src/peft/tuners/cpt/model.py#L66)

**Параметры:**

indices (torch.Tensor) : Индексы токенов, подлежащие встраиванию.

**Возвращает:** `torch.Tensor`

Сумма эмбеддингов промпта и дельта-эмбеддингов.

Вычисляет эмбеддинги промпта и применяет дельта-корректировки.

#### get_projection[[peft.CPTEmbedding.get_projection]]

```python
get_projection()
```

[Источник](https://github.com/huggingface/peft/blob/v0.22.0/src/peft/tuners/cpt/model.py#L126)

Применяет проекцию на основе эпсилона к дельта-эмбеддингам для контроля их нормы.

#### set_updated_tokens[[peft.CPTEmbedding.set_updated_tokens]]

```python
set_updated_tokens()
```

[Источник](https://github.com/huggingface/peft/blob/v0.22.0/src/peft/tuners/cpt/model.py#L87)

Устанавливает обратный хук для выборочного обновления градиентов токенов на основе маски типа токенов CPT.

