# CANINE

[CANINE](https://huggingface.co/papers/2103.06874) — это Transformer без токенизации. Он пропускает стандартный этап разбиения текста на подслов или wordpieces и обрабатывает текст посимвольно. Это означает, что модель работает непосредственно с «сырыми» символами Unicode, что делает её особенно полезной для языков со сложными или непоследовательными правилами токенизации, а также для зашумлённых входных данных, например, содержащих опечатки. Поскольку работа с символами подразумевает обработку более длинных последовательностей, CANINE использует хитрый приём. Модель сжимает входные данные на раннем этапе (этап называется downsampling), чтобы трансформеру не приходилось обрабатывать каждый символ по отдельности. Это позволяет сохранять высокую скорость и эффективность.

Все исходные контрольные точки CANINE можно найти в организации [Google](https://huggingface.co/google?search_models=canine).

> [!TIP]
> Щёлкните по моделям CANINE в боковой панели справа, чтобы увидеть дополнительные примеры применения CANINE к различным языковым задачам.

Приведённый ниже пример показывает, как генерировать эмбеддинги с помощью [Pipeline](/docs/transformers/v5.23.0/ru/main_classes/pipelines#transformers.Pipeline), [AutoModel](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoModel) и из командной строки.

```python
from transformers import pipeline

pipeline = pipeline(
    task="feature-extraction",
    model="google/canine-c",
    device=0,
)

pipeline("Plant create energy through a process known as photosynthesis.")
```

```python
import torch

from transformers import AutoModel

model = AutoModel.from_pretrained("google/canine-c", device_map="auto")

text = "Plant create energy through a process known as photosynthesis."
input_ids = torch.tensor([[ord(char) for char in text]])

outputs = model(input_ids)
pooled_output = outputs.pooler_output
sequence_output = outputs.last_hidden_state
```

## Примечания

- CANINE полностью обходит токенизацию — он работает непосредственно с исходными символами, а не с сабвордами. Его можно использовать как с токенизатором, так и без него. Для пакетного вывода и обучения рекомендуется использовать токенизатор, чтобы дополнить и обрезать все последовательности до одинаковой длины.

    ```py
    from transformers import AutoTokenizer, AutoModel

    tokenizer = AutoTokenizer("google/canine-c")
    inputs = ["Life is like a box of chocolates.", "You never know what you gonna get."]
    encoding = tokenizer(inputs, padding="longest", truncation=True, return_tensors="pt").to(model.device)
    ```

- CANINE в первую очередь предназначен для дообучения на конкретной задаче. Предобученная модель может использоваться как для моделирования языка с маскированием, так и для предсказания следующего предложения.

## CanineConfig[[transformers.CanineConfig]]

#### transformers.CanineConfig[[transformers.CanineConfig]]

```python
transformers.CanineConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.1, attention_probs_dropout_prob: float | int = 0.1, max_position_embeddings: int = 16384, type_vocab_size: int = 16, initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, pad_token_id: int | None = 0, bos_token_id: int | None = 57344, eos_token_id: int | list[int] | None = 57345, downsampling_rate: int = 4, upsampling_kernel_size: int = 4, num_hash_functions: int = 8, num_hash_buckets: int = 16384, local_transformer_stride: int = 128)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/canine/configuration_canine.py#L24)

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

hidden_size (`int`, *optional*, по умолчанию `768`) : Размерность скрытых представлений.

num_hidden_layers (`int`, *необязательный*, по умолчанию `12`) : Количество скрытых слоев в декодере Transformer.

num_attention_heads (`int`, *необязательный*, по умолчанию `12`) : Количество головок внимания для каждого слоя внимания в декодере Transformer.

intermediate_size (`int`, *optional*, по умолчанию `3072`) : Размерность представлений MLP.

hidden_act (`str`, *необязательный*, по умолчанию `gelu`) : Нелинейная функция активации (функция или строка) в декодере. Например, `"gelu"`, `"relu"`, `"silu"` и т. д.

hidden_dropout_prob (`Union[float, int]`, *необязательный*, по умолчанию `0.1`) : Вероятность dropout для всех полносвязных слоев в эмбеддингах, энкодере и пулере.

attention_probs_dropout_prob (`Union[float, int]`, *необязательный*, по умолчанию `0.1`) : Доля dropout для вероятностей внимания.

max_position_embeddings (`int`, *необязательный*, по умолчанию `16384`) : Максимальная длина последовательности, с которой может использоваться эта модель.

type_vocab_size (`int`, *необязательный*, по умолчанию `16`) : Размер словаря для `token_type_ids`.

initializer_range (`float`, *необязательный*, по умолчанию `0.02`) : Стандартное отклонение truncated_normal_initializer для инициализации всех матриц весов.

layer_norm_eps (`float`, *необязательный*, по умолчанию `1e-12`) : Значение epsilon, используемое слоями нормализации.

pad_token_id (`int`, *необязательный*, по умолчанию `0`) : Идентификатор токена, используемый для выравнивания в словаре.

bos_token_id (`int`, *необязательный*, по умолчанию `57344`) : Идентификатор токена, используемый для обозначения начала потока в словаре.

eos_token_id (`Union[int, list[int]]`, *необязательный*, по умолчанию `57345`) : Идентификатор токена, используемый для обозначения конца потока в словаре.

downsampling_rate (`int`, *optional*, по умолчанию 4) : Частота, с которой выполняется понижение дискретизации исходной длины последовательности символов перед применением глубокого Transformer-кодера.

upsampling_kernel_size (`int`, *optional*, по умолчанию 4) : Размер ядра (то есть количество символов в каждом окне) свёрточного проекционного слоя при обратном проецировании из `hidden_size`*2 в `hidden_size`.

num_hash_functions (`int`, *optional*, по умолчанию 8) : Количество хеш-функций для использования. У каждой хеш-функции есть собственная матрица эмбеддингов.

num_hash_buckets (`int`, *optional*, по умолчанию 16384) : Количество используемых хэш-корзин.

local_transformer_stride (`int`, *optional*, по умолчанию 128) : Шаг локального внимания первого неглубокого Transformer-энкодера. По умолчанию 128 для хорошей выравнивания памяти TPU/XLA.

Это класс конфигурации для хранения настроек модели CanineModel. Он используется для создания модели Canine в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации [google/canine-s](https://huggingface.co/google/canine-s)

Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig).

Пример:

```python
>>> from transformers import CanineConfig, CanineModel

>>> # Initializing a CANINE google/canine-s style configuration
>>> configuration = CanineConfig()

>>> # Initializing a model (with random weights) from the google/canine-s style configuration
>>> model = CanineModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## CanineTokenizer[[transformers.CanineTokenizer]]

#### transformers.CanineTokenizer[[transformers.CanineTokenizer]]

```python
transformers.CanineTokenizer(bos_token = '\ue000', eos_token = '\ue001', sep_token = '\ue001', cls_token = '\ue000', pad_token = '\x00', mask_token = '\ue003', add_prefix_space = False, model_max_length = 2048, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/canine/tokenization_canine.py#L55)

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

model_max_length (`int`, *optional*, по умолчанию 2048) : Максимальная длина предложения, которую принимает модель.

Создайте токенизатор CANINE (то есть разделитель по символам). Он преобразует текст в последовательность символов, а затем переводит каждый символ в его код Unicode.

[CanineTokenizer](/docs/transformers/v5.23.0/ru/model_doc/canine#transformers.CanineTokenizer) наследуется от [PreTrainedTokenizer](/docs/transformers/v5.23.0/ru/main_classes/tokenizer#transformers.PythonBackend).

См. примеры использования и документацию по параметрам в суперклассе [PreTrainedTokenizer](/docs/transformers/v5.23.0/ru/main_classes/tokenizer#transformers.PythonBackend).

#### build_inputs_with_special_tokens[[transformers.CanineTokenizer.build_inputs_with_special_tokens]]

```python
build_inputs_with_special_tokens(token_ids_0: list[int], token_ids_1: list[int] | None = None)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_python.py#L868)

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

token_ids_0 (`list[int]`) : Список идентификаторов, к которым будут добавлены специальные токены.

token_ids_1 (`list[int]`, *необязательный*) : Необязательный второй список идентификаторов для пар последовательностей.

**Возвращает:** `list[int]`

Список входных идентификаторов с соответствующими специальными токенами.

Создайте входные данные модели из последовательности или пары последовательностей, добавив специальные токены.

Этот метод динамически формирует входные данные на основе `special_tokens_pattern` токенизатора:
- `"none"`: без специальных токенов
- `"cls_sep"`: [CLS] seq0 [SEP] или [CLS] seq0 [SEP] seq1 [SEP]
- `"eos"`: seq0 [EOS] или seq0 [EOS] seq1 [EOS]
- `"bos"`: [BOS] seq0 или [BOS] seq0 [BOS] seq1
- `"bos_eos"`: [BOS] seq0 [EOS] или [BOS] seq0 [EOS] seq1 [EOS]
- `"cls_double_sep"`: [CLS] seq0 [SEP] или [CLS] seq0 [SEP] [SEP] seq1 [SEP]
- `"prefix_suffix"`: `<prefix_tokens> seq0 [seq1] <suffix_tokens>` (собственный префикс/суффикс, хранящийся в токенизаторе)

#### get_special_tokens_mask[[transformers.CanineTokenizer.get_special_tokens_mask]]

```python
get_special_tokens_mask(token_ids_0: list, token_ids_1: list | None = None, already_has_special_tokens: bool = False)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_python.py#L972)

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

token_ids_0 (`list[int]`) : Список идентификаторов первой последовательности.

token_ids_1 (`list[int]`, *необязательный*) : Список идентификаторов второй последовательности.

already_has_special_tokens (`bool`, *необязательный*, по умолчанию `False`) : Указывает, является ли список токенов уже отформатированным со специальными токенами для модели.

**Возвращаемое значение:** список целых чисел в диапазоне [0, 1]

1 для специального токена, 0 для токена последовательности.

Получает идентификаторы последовательностей из списка токенов, в который не добавлены специальные токены. Этот метод вызывается при добавлении специальных токенов с помощью методов `prepare_for_model` или `encode_plus` токенизатора.

Этот метод динамически формирует маску специальных токенов на основе `special_tokens_pattern` токенизатора:
- `"none"`: без специальных токенов (по умолчанию, возвращает все нули)
- `"cls_sep"`: [CLS] seq0 [SEP] или [CLS] seq0 [SEP] seq1 [SEP]
- `"eos"`: seq0 [EOS] или seq0 [EOS] seq1 [EOS]
- `"bos"`: [BOS] seq0 или [BOS] seq0 [BOS] seq1
- `"bos_eos"`: [BOS] seq0 [EOS] или [BOS] seq0 [EOS] seq1 [EOS]
- `"cls_double_sep"`: [CLS] seq0 [SEP] или [CLS] seq0 [SEP] [SEP] seq1 [SEP]
- `"prefix_suffix"`: `<prefix_tokens> seq0 [seq1] <suffix_tokens>`

#### create_token_type_ids_from_sequences[[transformers.CanineTokenizer.create_token_type_ids_from_sequences]]

```python
create_token_type_ids_from_sequences(token_ids_0: list[int], token_ids_1: list[int] | None = None)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_python.py#L1301)

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

token_ids_0 (`list[int]`) : Список идентификаторов.

token_ids_1 (`list[int]`, *необязательный*) : Необязательный второй список идентификаторов для пар последовательностей.

**Возвращает:** `list[int]`

Идентификаторы типов токенов в соответствии с настроенным шаблоном.

Создайте маску из двух переданных последовательностей для использования в задаче классификации пар последовательностей.

Этот метод динамически формирует идентификаторы типов токенов на основе атрибутов конфигурации токенизатора:
- `token_type_ids_pattern`: Шаблон для использования ("all_zeros" или "bert_style")
- `token_type_ids_include_special_tokens`: Учитывать ли специальные токены при вычислении длины

Примеры:
```python
# All zeros pattern (default, used by RoBERTa, BART, etc.)
tokenizer.token_type_ids_pattern = "all_zeros"
# Returns: [0, 0, 0, ...] for both sequences

# BERT-style pattern (first sequence gets 0s, second gets 1s)
tokenizer.token_type_ids_pattern = "bert_style"
# Returns: [0, 0, 0, ..., 1, 1, 1, ...] for sequence pairs
```

## Специфические выходные данные CANINE[[transformers.models.canine.modeling_canine.CanineModelOutputWithPooling]]

#### transformers.models.canine.modeling_canine.CanineModelOutputWithPooling[[transformers.models.canine.modeling_canine.CanineModelOutputWithPooling]]

```python
transformers.models.canine.modeling_canine.CanineModelOutputWithPooling(last_hidden_state: typing.Optional[torch.Tensor] = None, pooler_output: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor] | None = None, attentions: tuple[torch.Tensor] | None = None)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/canine/modeling_canine.py#L57)

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

last_hidden_state (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`) : Последовательность скрытых состояний на выходе последнего слоя модели (то есть выход финального неглубокого кодировщика Transformer).

pooler_output (`torch.Tensor` формы `(batch_size, hidden_size)`) : Скрытое состояние первого токена последовательности (токен классификации) на последнем слое глубокого Transformer-энкодера, дополнительно обработанное линейным слоем и функцией активации Tanh. Веса линейного слоя обучаются по задаче предсказания следующего предложения (классификации) во время предварительного обучения.

hidden_states (`tuple(torch.Tensor)`, *необязательный*, возвращается, если передано `output_hidden_states=True` или если `config.output_hidden_states=True`) : Кортеж из `torch.Tensor` (по одному для входа в каждый энкодер + по одному для выхода каждого слоя каждого энкодера) с формами `(batch_size, sequence_length, hidden_size)` и `(batch_size, sequence_length // config.downsampling_rate, hidden_size)`. Скрытые состояния модели на выходе каждого слоя, а также исходный вход в каждый энкодер Transformer. Скрытые состояния неглубоких энкодеров имеют длину `sequence_length`, но скрытые состояния глубокого энкодера имеют длину `sequence_length` // `config.downsampling_rate`.

attentions (`tuple(torch.Tensor)`, *необязательный*, возвращается, если передано `output_attentions=True` или если `config.output_attentions=True`) : Кортеж из `torch.Tensor` (по одному на каждый слой) для трёх кодировщиков Transformer с формами `(batch_size, num_heads, sequence_length, sequence_length)` и `(batch_size, num_heads, sequence_length // config.downsampling_rate, sequence_length // config.downsampling_rate)`. Веса внимания после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

Тип выходных данных [CanineModel](/docs/transformers/v5.23.0/ru/model_doc/canine#transformers.CanineModel). Основан на [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling), но с немного другими `hidden_states` и `attentions`, так как они также включают скрытые состояния и внимания неглубоких трансформерных энкодеров.

## CanineModel[[transformers.CanineModel]]

#### transformers.CanineModel[[transformers.CanineModel]]

```python
transformers.CanineModel(config: CanineConfig, add_pooling_layer = True)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/canine/modeling_canine.py#L727)

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

config ([CanineConfig](/docs/transformers/v5.23.0/ru/model_doc/canine#transformers.CanineConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

add_pooling_layer (`bool`, *необязательный*, по умолчанию `True`) : Нужно ли добавлять слой пулинга

Модель Canine без дополнительных слоёв, выводящая необработанные скрытые состояния.

Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### forward[[transformers.CanineModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/canine/modeling_canine.py#L829)

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

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids)

attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.  [Что такое маски внимания?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы токенов сегментов для указания первой и второй частей входных данных. Индексы выбираются из `[0, 1]`:  - 0 соответствует токену *предложения A*, - 1 соответствует токену *предложения B*.  [Что такое идентификаторы типов токенов?](../glossary#token-type-ids)

position_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Выбираются из диапазона `[0, config.n_positions - 1]`.  [Что такое position IDs?](../glossary#position-ids)

inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели.

output_attentions (`bool`, *необязательный*) : Нужно ли возвращать тензоры внимания всех слоев внимания. Подробнее см. `attentions` в разделе возвращаемых тензоров.

output_hidden_states (`bool`, *необязательный*) : Нужно ли возвращать скрытые состояния всех слоёв. Подробнее о `hidden_states` в разделе возвращаемых тензоров.

return_dict (`bool`, *необязательный*) : Нужно ли возвращать [ModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.utils.ModelOutput) вместо обычного кортежа.

**Возвращает:** [CanineModelOutputWithPooling](/docs/transformers/v5.23.0/ru/model_doc/canine#transformers.models.canine.modeling_canine.CanineModelOutputWithPooling) или `tuple(torch.Tensor)`

Объект [CanineModelOutputWithPooling](/docs/transformers/v5.23.0/ru/model_doc/canine#transformers.models.canine.modeling_canine.CanineModelOutputWithPooling) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([CanineConfig](/docs/transformers/v5.23.0/ru/model_doc/canine#transformers.CanineConfig)) и входных данных.

Метод forward модели [CanineModel](/docs/transformers/v5.23.0/ru/model_doc/canine#transformers.CanineModel) переопределяет специальный метод `__call__`.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует.

- **last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`) -- Последовательность скрытых состояний на выходе последнего слоя модели (т. е. выход последнего неглубокого кодировщика Transformer).
- **pooler_output** (`torch.Tensor` формы `(batch_size, hidden_size)`) -- Скрытое состояние первого токена последовательности (токен классификации) на последнем слое глубокого Transformer-энкодера, дополнительно обработанное линейным слоем и функцией активации Tanh. Веса линейного слоя обучаются по задаче предсказания следующего предложения (классификации) во время предварительного обучения.
- **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или при `config.output_hidden_states=True`) — Кортеж `torch.Tensor` (по одному для входа в каждый энкодер и по одному для выхода каждого слоя каждого энкодера) с формами `(batch_size, sequence_length, hidden_size)` и `(batch_size, sequence_length // config.downsampling_rate, hidden_size)`. Скрытые состояния модели на выходе каждого слоя, а также исходный вход в каждый энкодер Transformer. Скрытые состояния неглубоких энкодеров имеют длину `sequence_length`, но скрытые состояния глубокого энкодера имеют длину `sequence_length` // `config.downsampling_rate`.
- **attentions** (`tuple(torch.Tensor)`, *optional*, возвращается, если передано `output_attentions=True` или если `config.output_attentions=True`) — Кортеж из `torch.Tensor` (по одному на каждый слой) для трёх энкодеров Transformer с формами `(batch_size, num_heads, sequence_length, sequence_length)` и `(batch_size, num_heads, sequence_length // config.downsampling_rate, sequence_length // config.downsampling_rate)`. Веса внимания после softmax-функции внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

## CanineForSequenceClassification[[transformers.CanineForSequenceClassification]]

#### transformers.CanineForSequenceClassification[[transformers.CanineForSequenceClassification]]

```python
transformers.CanineForSequenceClassification(config: CanineConfig)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/canine/modeling_canine.py#L995)

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

config ([CanineConfig](/docs/transformers/v5.23.0/ru/model_doc/canine#transformers.CanineConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

CANINE Модель-трансформер с головой для классификации/регрессии последовательности (линейный слой поверх пуллинг-выхода), например, для задач GLUE.

Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### forward[[transformers.CanineForSequenceClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/canine/modeling_canine.py#L1007)

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

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids)

attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.  [Что такое маски внимания?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы токенов сегментов для указания первой и второй частей входных данных. Индексы выбираются из `[0, 1]`:  - 0 соответствует токену *предложения A*, - 1 соответствует токену *предложения B*.  [Что такое идентификаторы типов токенов?](../glossary#token-type-ids)

position_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Выбираются из диапазона `[0, config.n_positions - 1]`.  [Что такое position IDs?](../glossary#position-ids)

inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели.

labels (`torch.LongTensor` формы `(batch_size,)`, *необязательный*) : Метки для вычисления функции потерь классификации/регрессии последовательности. Индексы должны находиться в диапазоне `[0, ..., config.num_labels - 1]`. Если `config.num_labels == 1`, вычисляется функция потерь регрессии (среднеквадратичная ошибка), если `config.num_labels > 1` — функция потерь классификации (кросс-энтропия).

output_attentions (`bool`, *необязательный*) : Нужно ли возвращать тензоры внимания всех слоев внимания. Подробнее см. `attentions` в разделе возвращаемых тензоров.

output_hidden_states (`bool`, *необязательный*) : Нужно ли возвращать скрытые состояния всех слоёв. Подробнее о `hidden_states` в разделе возвращаемых тензоров.

return_dict (`bool`, *необязательный*) : Нужно ли возвращать [ModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.utils.ModelOutput) вместо обычного кортежа.

**Возвращает:** [SequenceClassifierOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) или `tuple(torch.Tensor)`

Объект [SequenceClassifierOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) или кортеж из `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([CanineConfig](/docs/transformers/v5.23.0/ru/model_doc/canine#transformers.CanineConfig)) и входных данных.

Метод forward класса [CanineForSequenceClassification](/docs/transformers/v5.23.0/ru/model_doc/canine#transformers.CanineForSequenceClassification) переопределяет специальный метод `__call__`.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует.

- **loss** (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если задан `labels`) -- Потери классификации (или регрессии, если config.num_labels==1).
- **logits** (`torch.Tensor` формы `(batch_size, config.num_labels)`) — Оценки классификации (или регрессии, если config.num_labels==1) до применения SoftMax.
- **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или когда `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

  Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания.
- **attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

  Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

Пример классификации с одной меткой:

```python
>>> import torch
>>> from transformers import AutoTokenizer, CanineForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("google/canine-s")
>>> model = CanineForSequenceClassification.from_pretrained("google/canine-s")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
...

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = CanineForSequenceClassification.from_pretrained("google/canine-s", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...
```

Пример многоклассовой классификации:

```python
>>> import torch
>>> from transformers import AutoTokenizer, CanineForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("google/canine-s")
>>> model = CanineForSequenceClassification.from_pretrained("google/canine-s", problem_type="multi_label_classification")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = CanineForSequenceClassification.from_pretrained(
...     "google/canine-s", num_labels=num_labels, problem_type="multi_label_classification"
... )

>>> labels = torch.sum(
...     torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).loss
```

## CanineForMultipleChoice[[transformers.CanineForMultipleChoice]]

#### transformers.CanineForMultipleChoice[[transformers.CanineForMultipleChoice]]

```python
transformers.CanineForMultipleChoice(config: CanineConfig)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/canine/modeling_canine.py#L1074)

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

config ([CanineConfig](/docs/transformers/v5.23.0/ru/model_doc/canine#transformers.CanineConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Модель Canine с головой для классификации с множественным выбором (линейный слой поверх пул-вывода и softmax), например, для задач RocStories/SWAG.

Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### forward[[transformers.CanineForMultipleChoice.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/canine/modeling_canine.py#L1085)

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

input_ids (`torch.LongTensor` формы `(batch_size, num_choices, sequence_length)`) : Индексы токенов входной последовательности в словаре. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids)

attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.  [Что такое маски внимания?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` формы `(batch_size, num_choices, sequence_length)`, *необязательно*) : Индексы сегментных токенов для указания первой и второй частей входных данных. Индексы выбираются из `[0, 1]`:  - 0 соответствует токену *предложения A*, - 1 соответствует токену *предложения B*.  [Что такое идентификаторы типов токенов?](../glossary#token-type-ids)

position_ids (`torch.LongTensor` формы `(batch_size, num_choices, sequence_length)`, *необязательно*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Выбираются из диапазона `[0, config.max_position_embeddings - 1]`.  [Что такое position IDs?](../glossary#position-ids)

inputs_embeds (`torch.Tensor` формы `(batch_size, num_choices, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы *input_ids* преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели.

labels (`torch.LongTensor` формы `(batch_size,)`, *необязательный*) : Метки для вычисления функции потерь классификации с множественным выбором. Индексы должны находиться в диапазоне `[0, ..., num_choices-1]`, где `num_choices` — размер второго измерения входных тензоров. (См. `input_ids` выше)

output_attentions (`bool`, *необязательный*) : Нужно ли возвращать тензоры внимания всех слоев внимания. Подробнее см. `attentions` в разделе возвращаемых тензоров.

output_hidden_states (`bool`, *необязательный*) : Нужно ли возвращать скрытые состояния всех слоёв. Подробнее о `hidden_states` в разделе возвращаемых тензоров.

return_dict (`bool`, *необязательный*) : Нужно ли возвращать [ModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.utils.ModelOutput) вместо обычного кортежа.

**Возвращает:** [MultipleChoiceModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.MultipleChoiceModelOutput) или `tuple(torch.Tensor)`

Объект [MultipleChoiceModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.MultipleChoiceModelOutput) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([CanineConfig](/docs/transformers/v5.23.0/ru/model_doc/canine#transformers.CanineConfig)) и входных данных.

Метод forward класса [CanineForMultipleChoice](/docs/transformers/v5.23.0/ru/model_doc/canine#transformers.CanineForMultipleChoice) переопределяет специальный метод `__call__`.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует.

- **loss** (`torch.Tensor` формы *(1,)*, *необязательный*, возвращается, если задан `labels`) -- Потери классификации.
- **logits** (`torch.Tensor` формы `(batch_size, num_choices)`) -- *num_choices* — это второе измерение входных тензоров (см. *input_ids* выше).

  Оценки классификации (до SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или когда `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

  Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания.
- **attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

  Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

Пример:

```python
>>> from transformers import AutoTokenizer, CanineForMultipleChoice
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("google/canine-s")
>>> model = CanineForMultipleChoice.from_pretrained("google/canine-s")

>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> labels = torch.tensor(0).unsqueeze(0)  # choice0 is correct (according to Wikipedia ;)), batch size 1

>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True)
>>> outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels)  # batch size is 1

>>> # the linear classifier still needs to be trained
>>> loss = outputs.loss
>>> logits = outputs.logits
```

## CanineForTokenClassification[[transformers.CanineForTokenClassification]]

#### transformers.CanineForTokenClassification[[transformers.CanineForTokenClassification]]

```python
transformers.CanineForTokenClassification(config: CanineConfig)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/canine/modeling_canine.py#L1173)

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

config ([CanineConfig](/docs/transformers/v5.23.0/ru/model_doc/canine#transformers.CanineConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Трансформер Canine с головой для классификации токенов (линейный слой поверх выходных скрытых состояний), например, для задач распознавания именованных сущностей (NER).

Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### forward[[transformers.CanineForTokenClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/canine/modeling_canine.py#L1185)

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

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids)

attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.  [Что такое маски внимания?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы токенов сегментов для указания первой и второй частей входных данных. Индексы выбираются из `[0, 1]`:  - 0 соответствует токену *предложения A*, - 1 соответствует токену *предложения B*.  [Что такое идентификаторы типов токенов?](../glossary#token-type-ids)

position_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Выбираются из диапазона `[0, config.n_positions - 1]`.  [Что такое position IDs?](../glossary#position-ids)

inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели.

labels (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Метки для вычисления функции потерь классификации токенов. Индексы должны находиться в диапазоне `[0, ..., config.num_labels - 1]`.

output_attentions (`bool`, *необязательный*) : Нужно ли возвращать тензоры внимания всех слоев внимания. Подробнее см. `attentions` в разделе возвращаемых тензоров.

output_hidden_states (`bool`, *необязательный*) : Нужно ли возвращать скрытые состояния всех слоёв. Подробнее о `hidden_states` в разделе возвращаемых тензоров.

return_dict (`bool`, *необязательный*) : Нужно ли возвращать [ModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.utils.ModelOutput) вместо обычного кортежа.

**Возвращает:** [TokenClassifierOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) или `tuple(torch.Tensor)`

Объект [TokenClassifierOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) или кортеж из `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([CanineConfig](/docs/transformers/v5.23.0/ru/model_doc/canine#transformers.CanineConfig)) и входных данных.

Метод forward класса [CanineForTokenClassification](/docs/transformers/v5.23.0/ru/model_doc/canine#transformers.CanineForTokenClassification) переопределяет специальный метод `__call__`.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует.

- **loss** (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если задан `labels`) -- Потери классификации.
- **logits** (`torch.Tensor` формы `(batch_size, sequence_length, config.num_labels)`) — Оценки классификации (до SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или когда `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

  Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания.
- **attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

  Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

Пример:

```python
>>> from transformers import AutoTokenizer, CanineForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("google/canine-s")
>>> model = CanineForTokenClassification.from_pretrained("google/canine-s")

>>> inputs = tokenizer(
...     "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_token_class_ids = logits.argmax(-1)

>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]
>>> predicted_tokens_classes
```

```python
>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
```

## CanineForQuestionAnswering[[transformers.CanineForQuestionAnswering]]

#### transformers.CanineForQuestionAnswering[[transformers.CanineForQuestionAnswering]]

```python
transformers.CanineForQuestionAnswering(config: CanineConfig)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/canine/modeling_canine.py#L1266)

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

config ([CanineConfig](/docs/transformers/v5.23.0/ru/model_doc/canine#transformers.CanineConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Трансформер Canine со слоем классификации пропусков (span classification head) сверху для задач извлекающего вопросно-ответного типа, таких как SQuAD (линейный слой поверх выходных скрытых состояний для вычисления `span start logits` и `span end logits`).

Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### forward[[transformers.CanineForQuestionAnswering.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.LongTensor] = None, end_positions: typing.Optional[torch.LongTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/canine/modeling_canine.py#L1277)

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

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids)

attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.  [Что такое маски внимания?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы токенов сегментов для указания первой и второй частей входных данных. Индексы выбираются из `[0, 1]`:  - 0 соответствует токену *предложения A*, - 1 соответствует токену *предложения B*.  [Что такое идентификаторы типов токенов?](../glossary#token-type-ids)

position_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Выбираются из диапазона `[0, config.n_positions - 1]`.  [Что такое position IDs?](../glossary#position-ids)

inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели.

start_positions (`torch.LongTensor` формы `(batch_size,)`, *необязательный*) : Метки для позиции (индекса) начала размеченного фрагмента для вычисления функции потерь классификации токенов. Позиции ограничиваются длиной последовательности (`sequence_length`). Позиции вне последовательности не учитываются при вычислении функции потерь.

end_positions (`torch.LongTensor` формы `(batch_size,)`, *необязательный*) : Метки для позиции (индекса) конца размеченного фрагмента для вычисления функции потерь классификации токенов. Позиции ограничиваются длиной последовательности (`sequence_length`). Позиции вне последовательности не учитываются при вычислении функции потерь.

output_attentions (`bool`, *необязательный*) : Нужно ли возвращать тензоры внимания всех слоев внимания. Подробнее см. `attentions` в разделе возвращаемых тензоров.

output_hidden_states (`bool`, *необязательный*) : Нужно ли возвращать скрытые состояния всех слоёв. Подробнее о `hidden_states` в разделе возвращаемых тензоров.

return_dict (`bool`, *необязательный*) : Нужно ли возвращать [ModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.utils.ModelOutput) вместо обычного кортежа.

**Возвращает:** [QuestionAnsweringModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) или `tuple(torch.Tensor)`

Объект [QuestionAnsweringModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([CanineConfig](/docs/transformers/v5.23.0/ru/model_doc/canine#transformers.CanineConfig)) и входных данных.

Метод forward класса [CanineForQuestionAnswering](/docs/transformers/v5.23.0/ru/model_doc/canine#transformers.CanineForQuestionAnswering) переопределяет специальный метод `__call__`.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует.

- **loss** (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если задан `labels`) -- Суммарная функция потерь для извлечения пролёгов представляет собой сумму кросс-энтропии для начальных и конечных позиций.
- **start_logits** (`torch.Tensor` формы `(batch_size, sequence_length)`) -- Оценки начала пропусков (до SoftMax).
- **end_logits** (`torch.Tensor` формы `(batch_size, sequence_length)`) -- Оценки конца пролета (до SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или когда `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

  Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания.
- **attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

  Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

Пример:

```python
>>> from transformers import AutoTokenizer, CanineForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("google/canine-s")
>>> model = CanineForQuestionAnswering.from_pretrained("google/canine-s")

>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"

>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()

>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
...

>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])

>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
...
```

