# GPT-NeoX ## Обзор Мы представляем [GPT-NeoX-20B](https://huggingface.co/papers/2204.06745) — авторегрессионную языковую модель с 20 миллиардами параметров, обученную на корпусе Pile, веса которой будут бесплатно и открыто доступны публике по свободной лицензии. Насколько нам известно, на момент подачи заявки это самая крупная плотная авторегрессионная модель с публично доступными весами. В данной работе мы описываем архитектуру и процесс обучения GPT-NeoX-20B, а также оцениваем её производительность на широком спектре задач понимания языка, математики и работы с знаниями. Мы обнаружили, что GPT-NeoX-20B является особенно мощным few-shot рассуждателем и демонстрирует значительно больший прирост производительности при оценке в режиме five-shot по сравнению с моделями GPT-3 и FairSeq сопоставимого размера. Мы открыли исходный код обучения и оценки, а также веса модели, по адресу [https://github.com/EleutherAI/gpt-neox](https://github.com/EleutherAI/gpt-neox). Разработка модели велась под руководством Sid Black, Stella Biderman и Eric Hallahan, а обучение модели было проведено при щедрой поддержке [CoreWeave](https://www.coreweave.com/). GPT-NeoX-20B обучался в fp16, поэтому рекомендуется инициализировать модель следующим образом: ```python model = GPTNeoXForCausalLM.from_pretrained("EleutherAI/gpt-neox-20b", device_map="auto") ``` GPT-NeoX-20B также использует другой токенизатор, чем тот, что применяется в GPT-J-6B и GPT-Neo. Новый токенизатор выделяет дополнительные токены для символов пробела, что делает модель более подходящей для определенных задач, таких как генерация кода. ## Пример использования Метод `generate()` можно использовать для генерации текста с помощью модели GPT Neo. ```python from transformers import GPTNeoXForCausalLM, GPTNeoXTokenizerFast model = GPTNeoXForCausalLM.from_pretrained("EleutherAI/gpt-neox-20b", device_map="auto") tokenizer = GPTNeoXTokenizerFast.from_pretrained("EleutherAI/gpt-neox-20b") prompt = "GPTNeoX20B is a 20B-parameter autoregressive Transformer model developed by EleutherAI." input_ids = tokenizer(prompt, return_tensors="pt").to(model.device).input_ids gen_tokens = model.generate( input_ids, do_sample=True, temperature=0.9, max_length=100, ) gen_text = tokenizer.batch_decode(gen_tokens)[0] ``` ## Использование Flash Attention 2 Flash Attention 2 — это более быстрая и оптимизированная версия модели. ### Установка Сначала проверьте, совместимо ли ваше оборудование с Flash Attention 2. Актуальный список совместимого оборудования можно найти в [официальной документации](https://github.com/Dao-AILab/flash-attention#installation-and-features). Далее [установите](https://github.com/Dao-AILab/flash-attention#installation-and-features) последнюю версию Flash Attention 2: ```bash pip install -U flash-attn --no-build-isolation ``` ### Использование Чтобы загрузить модель с использованием Flash Attention 2, мы можем передать аргумент `attn_implementation="flash_attention_2"` в [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained). Мы также загрузим модель в половинной точности (например, `torch.float16`), так как это приводит к почти незаметному снижению качества аудио, но значительно уменьшает потребление памяти и ускоряет инференс: ```python from transformers import GPTNeoXForCausalLM model = GPTNeoXForCausalLM.from_pretrained("EleutherAI/gpt-neox-20b", attn_implementation="flash_attention_2", device_map="auto") ... ``` ### Ожидаемое ускорение Ниже приведена диаграмма ожидаемого ускорения, сравнивающая время чистого инференса между нативной реализацией в transformers с использованием чекпоинта `stockmark/gpt-neox-japanese-1.4b` и версией модели с Flash Attention 2 при длине последовательности 2048. ## Использование масштабированного внимания на основе скалярного произведения (SDPA) PyTorch включает в себя нативный оператор масштабированного внимания на основе скалярного произведения (SDPA) в составе `torch.nn.functional`. Эта функция объединяет несколько реализаций, которые могут применяться в зависимости от входных данных и используемого оборудования. Подробнее см. в [официальной документации](https://pytorch.org/docs/stable/generated/torch.nn.functional.scaled_dot_product_attention.html) или на странице [GPU Inference](https://huggingface.co/docs/transformers/main/en/perf_infer_gpu_one#pytorch-scaled-dot-product-attention). SDPA используется по умолчанию для `torch>=2.1.1`, когда доступна соответствующая реализация, но вы также можете установить `attn_implementation="sdpa"` в `from_pretrained()`, чтобы явно запросить использование SDPA. ```python from transformers import GPTNeoXForCausalLM model = GPTNeoXForCausalLM.from_pretrained("EleutherAI/gpt-neox-20b", attn_implementation="sdpa", device_map="auto") ... ``` Для достижения максимального ускорения мы рекомендуем загружать модель в половинной точности (например, `torch.float16` или `torch.bfloat16`). На локальном бенчмарке (rtx3080ti-16GB, PyTorch 2.2.1, ОС Ubuntu 22.04) с использованием `float16` и [pythia-410m-deduped](https://huggingface.co/EleutherAI/pythia-410m-deduped) мы наблюдали следующие ускорения при обучении и инференсе. ### Обучение | Размер пакета | Длина последовательности | Время на батч (Eager - с) | Время на батч (SDPA - с) | Ускорение (%) | Пиковая память Eager (МБ) | Пиковая память SDPA (МБ) | Экономия памяти (%) | |-----------:|-----------:|---------------------------:|-----------------------------:|------------:|--------------------:|-------------------:|------------------:| | 1 | 128 | 0.024 | 0.019 | 28.945 | 1789.95 | 1789.95 | 0 | | 1 | 256 | 0.039 | 0.031 | 23.18 | 1845.83 | 1844.84 | 0.053 | | 1 | 512 | 0.08 | 0.055 | 45.524 | 2278.38 | 1953.76 | 16.615 | | 1 | 1024 | 0.19 | 0.102 | 86.777 | 4772.36 | 2408.35 | 98.159 | | 1 | 2048 | 0.565 | 0.204 | 177.098 | 13484.1 | 3882.01 | 247.348 | | 2 | 128 | 0.037 | 0.032 | 15.121 | 1843.86 | 1844.78 | -0.05 | | 2 | 256 | 0.067 | 0.055 | 21.706 | 1999.72 | 1951.67 | 2.462 | | 2 | 512 | 0.144 | 0.096 | 50.046 | 3613.16 | 2406.77 | 50.125 | | 2 | 1024 | 0.366 | 0.193 | 89.666 | 8707.55 | 3878.86 | 124.487 | | 2 | 2048 | OOM | 0.379 | / | OOM | 6825.13 | SDPA не приводит к OOM | | 4 | 128 | 0.06 | 0.054 | 11.539 | 1947.6 | 1952.06 | -0.228 | | 4 | 256 | 0.119 | 0.093 | 28.072 | 3008.39 | 2405.99 | 25.038 | | 4 | 512 | 0.275 | 0.187 | 47.145 | 6290.58 | 3877.29 | 62.242 | | 4 | 1024 | OOM | 0.36 | / | OOM | 6821.98 | SDPA не приводит к OOM | | 4 | 2048 | OOM | 0.731 | / | OOM | 12705.1 | SDPA не приводит к OOM | ### Вывод | Размер пакета | Длина последовательности | Задержка на токен Eager (мс) | Задержка на токен SDPA (мс) | Ускорение (%) | Память Eager (МБ) | Память SDPA (МБ) | Сэкономлено памяти (%) | |--------------:|-------------:|--------------------------------:|-------------------------------:|---------------:|------------------:|----------------:|-----------------:| | 1 | 128 | 6.569 | 5.858 | 12.14 | 974.831 | 974.826 | 0 | | 1 | 256 | 7.009 | 5.863 | 19.542 | 1029.01 | 1028.08 | 0.09 | | 1 | 512 | 7.157 | 5.965 | 19.983 | 1137.54 | 1137.52 | 0.001 | | 1 | 1024 | 7.523 | 6.506 | 15.637 | 1329.3 | 1329.26 | 0.003 | | 1 | 2048 | 9.271 | 9.205 | 0.713 | 1752.47 | 1734.51 | 1.036 | | 2 | 128 | 7.239 | 5.959 | 21.493 | 1044.8 | 1028.37 | 1.597 | | 2 | 256 | 7.228 | 6.036 | 19.757 | 1167.32 | 1137.73 | 2.601 | | 2 | 512 | 7.538 | 6.693 | 12.628 | 1352.93 | 1329.55 | 1.758 | | 2 | 1024 | 8.916 | 8.632 | 3.291 | 1752.56 | 1734.62 | 1.034 | | 2 | 2048 | 12.628 | 12.606 | 0.181 | 2558.72 | 2545.8 | 0.508 | | 4 | 128 | 7.278 | 6.046 | 20.373 | 1168.41 | 1137.79 | 2.691 | | 4 | 256 | 7.614 | 6.588 | 15.574 | 1353.1 | 1329.79 | 1.753 | | 4 | 512 | 8.798 | 8.144 | 8.028 | 1752.76 | 1734.85 | 1.032 | | 4 | 1024 | 11.765 | 11.303 | 4.09 | 2558.96 | 2546.04 | 0.508 | | 4 | 2048 | 19.568 | 17.735 | 10.33 | 4175.5 | 4165.26 | 0.246 | ## Ресурсы - [Руководство по задаче каузального языкового моделирования](../tasks/language_modeling) ## GPTNeoXConfig[[transformers.GPTNeoXConfig]] #### transformers.GPTNeoXConfig[[transformers.GPTNeoXConfig]] ```python transformers.GPTNeoXConfig(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, vocab_size: int = 50432, hidden_size: int = 6144, num_hidden_layers: int = 44, num_attention_heads: int = 64, intermediate_size: int = 24576, hidden_act: str = 'gelu', attention_dropout: float | int = 0.0, hidden_dropout: float | int = 0.0, classifier_dropout: float | int = 0.1, max_position_embeddings: int = 2048, initializer_range: float = 0.02, layer_norm_eps: float = 1e-05, use_cache: bool = True, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 2, pad_token_id: int | None = None, tie_word_embeddings: bool = False, use_parallel_residual: bool = True, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, attention_bias: bool = True, is_decoder: bool = False) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gpt_neox/configuration_gpt_neox.py#L25) **Параметры:** vocab_size (`int`, *необязательный*, по умолчанию `50432`) : Размер словаря модели. Определяет количество различных токенов, которые могут быть представлены в `input_ids`. hidden_size (`int`, *optional*, по умолчанию `6144`) : Размерность скрытых представлений. num_hidden_layers (`int`, *необязательный*, по умолчанию `44`) : Количество скрытых слоев в декодере Transformer. num_attention_heads (`int`, *необязательный*, по умолчанию `64`) : Количество головок внимания для каждого слоя внимания в декодере Transformer. intermediate_size (`int`, *необязательный*, по умолчанию `24576`) : Размерность представлений MLP. hidden_act (`str`, *необязательный*, по умолчанию `gelu`) : Нелинейная функция активации (функция или строка) в декодере. Например, `"gelu"`, `"relu"`, `"silu"` и т. д. attention_dropout (`Union[float, int]`, *необязательный*, по умолчанию `0.0`) : Коэффициент dropout для вероятностей внимания. hidden_dropout (`Union[float, int]`, *необязательный*, по умолчанию `0.0`) : Вероятность dropout для всех полносвязных слоёв в эмбеддингах, энкодере и пулере. classifier_dropout (`Union[float, int]`, *необязательный*, по умолчанию `0.1`) : Коэффициент dropout для классификатора. max_position_embeddings (`int`, *необязательный*, по умолчанию `2048`) : Максимальная длина последовательности, с которой может использоваться данная модель. initializer_range (`float`, *необязательный*, по умолчанию `0.02`) : Стандартное отклонение truncated_normal_initializer для инициализации всех матриц весов. layer_norm_eps (`float`, *необязательный*, по умолчанию `1e-05`) : Значение epsilon, используемое слоями нормализации. use_cache (`bool`, *необязательный*, по умолчанию `True`) : Следует ли модели возвращать последние значения внимания key/values (не используется во всех моделях). Актуально только при `config.is_decoder=True` или если модель является генеративной моделью только с декодером. bos_token_id (`int`, *необязательный*, по умолчанию `0`) : Идентификатор токена, используемый для обозначения начала потока в словаре. eos_token_id (`Union[int, list[int]]`, *необязательный*, по умолчанию `2`) : Идентификатор токена, используемого для обозначения конца потока в словаре. pad_token_id (`int`, *необязательный*) : Идентификатор токена, используемый для выравнивания в словаре. tie_word_embeddings (`bool`, *необязательный*, по умолчанию `False`) : Связывать ли веса эмбеддингов согласно отображению `tied_weights_keys` модели. use_parallel_residual (`bool`, *необязательный*, по умолчанию `True`) : Использовать ли «параллельную» формулировку в каждом слое Transformer, что может обеспечить небольшое ускорение обучения при больших масштабах (например, 20B). rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *optional*) : Словарь, содержащий параметры конфигурации для вложений RoPE. Словарь должен содержать значение для `rope_theta` и, при необходимости, параметры, используемые для масштабирования, если вы хотите использовать RoPE с более длинными `max_position_embeddings`. attention_bias (`bool`, *необязательный*, по умолчанию `True`) : Использовать ли смещение (bias) в слоях проекции запроса, ключа, значения и вывода при само-внимании. is_decoder (`bool`, *необязательный*, по умолчанию `False`) : Указывает, используется ли модель в качестве декодера. Если `False`, модель используется как энкодер. Это класс конфигурации для хранения настроек модели GPTNeoXModel. Он используется для создания модели Gpt Neox в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации модели [EleutherAI/gpt-neox-20b](https://huggingface.co/EleutherAI/gpt-neox-20b) Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig). Пример: ```python >>> from transformers import GPTNeoXConfig, GPTNeoXModel >>> # Initializing a GPTNeoX gpt-neox-20b style configuration >>> configuration = GPTNeoXConfig() >>> # Initializing a model (with random weights) from the gpt-neox-20b style configuration >>> model = GPTNeoXModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## GPTNeoXTokenizer[[transformers.GPTNeoXTokenizer]] #### transformers.GPTNeoXTokenizer[[transformers.GPTNeoXTokenizer]] ```python transformers.GPTNeoXTokenizer(vocab: str | dict[str, int] | None = None, merges: str | list[str] | None = None, errors: str = 'replace', unk_token: str = '<|endoftext|>', bos_token: str = '<|endoftext|>', eos_token: str = '<|endoftext|>', pad_token: str = '<|padding|>', add_prefix_space: bool = False, trim_offsets: bool = True, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gpt_neox/tokenization_gpt_neox.py#L28) **Параметры:** vocab_file (`str`, *необязательный*) : Путь к файлу словаря. merges_file (`str`, *необязательный*) : Путь к файлу слияний. tokenizer_file (`str`, *необязательный*) : Путь к JSON-файлу токенизатора, содержащему сериализацию токенизатора. errors (`str`, *необязательный*, по умолчанию `"replace"`) : Парадигма, которой следует при декодировании байтов в UTF-8. Подробнее см. [bytes.decode](https://docs.python.org/3/library/stdtypes.html#bytes.decode). unk_token (`str`, *необязательный*, по умолчанию `"<|endoftext|>"`) : Токен неизвестного слова. Токен, отсутствующий в словаре, не может быть преобразован в ID, вместо этого ему присваивается данный токен. bos_token (`str`, *необязательный*, по умолчанию `"<|endoftext|>"`) : Токен начала последовательности. eos_token (`str`, *необязательный*, по умолчанию `"<|endoftext|>"`) : Токен конца последовательности. pad_token (`str`, *необязательный*, по умолчанию `"<|padding|>"`) : Токен для выравнивания последовательности. add_prefix_space (`bool`, *необязательный*, по умолчанию `False`) : Добавлять ли начальный пробел к входным данным. Это позволяет обрабатывать первое слово так же, как и любое другое. (Токенизатор GPTNeoX определяет начало слов по предшествующему пробелу). add_bos_token (`bool`, *необязательный*, по умолчанию `False`) : Добавлять ли `bos_token` в начало последовательностей. add_eos_token (`bool`, *необязательный*, по умолчанию `False`) : Добавлять ли `eos_token` в конце последовательностей. trim_offsets (`bool`, *необязательный*, по умолчанию `True`) : Указывает, следует ли на этапе постобработки обрезать смещения, чтобы избежать включения пробельных символов. vocab (`str` или `dict[str, int]`, *необязательный*) : Пользовательский словарь. Если не указан, словарь загружается из `vocab_file`. merges (`str` или `list[str]`, *необязательный*) : Пользовательский список слияний. Если не указан, слияния загружаются из `merges_file`. Создайте токенизатор GPT-NeoX-20B (на базе библиотеки tokenizers от HuggingFace). Основан на байтовом уровне Byte-Pair-Encoding. Этот токенизатор обучен обрабатывать пробелы как часть токенов (немного в духе sentencepiece), поэтому слово будет кодируются по-разному в зависимости от того, находятся ли они в начале предложения (без пробела) или нет: ```python >>> from transformers import GPTNeoXTokenizer >>> tokenizer = GPTNeoXTokenizer.from_pretrained("EleutherAI/gpt-neox-20b") >>> tokenizer("Hello world")["input_ids"] [15496, 995] >>> tokenizer(" Hello world")["input_ids"] [18435, 995] ``` Этому поведению можно избежать, передав `add_prefix_space=True` при создании экземпляра этого токенизатора, однако, поскольку модель не была предобучена таким образом, это может привести к снижению производительности. При использовании с `is_split_into_words=True` этот токенизатор необходимо инициализировать с `add_prefix_space=True`. Этот токенизатор наследуется от [TokenizersBackend](/docs/transformers/main/ru/main_classes/tokenizer#transformers.TokenizersBackend), который содержит большинство основных методов. За дополнительной информацией об этих методах следует обращаться к этому суперклассу. ## GPTNeoXModel[[transformers.GPTNeoXModel]] #### transformers.GPTNeoXModel[[transformers.GPTNeoXModel]] ```python transformers.GPTNeoXModel(config: GPTNeoXConfig) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gpt_neox/modeling_gpt_neox.py#L294) **Параметры:** config ([GPTNeoXConfig](/docs/transformers/main/ru/model_doc/gpt_neox#transformers.GPTNeoXConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. Модель Gpt Neox без дополнительных слоёв, выводящая необработанные скрытые состояния. Эта модель наследуется от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса. Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением. #### forward[[transformers.GPTNeoXModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, use_cache: bool | None = None, **kwargs: *) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gpt_neox/modeling_gpt_neox.py#L309) **Параметры:** input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/main/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/main/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) 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` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели. past_key_values (`~cache_utils.Cache`, *необязательный*) : Предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и кросс-внимания), которые можно использовать для ускорения последовательного декодирования. Обычно это `past_key_values`, возвращаемые моделью на предыдущем этапе декодирования, когда `use_cache=True` или `config.use_cache=True`. В качестве входного значения допускается только экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache), см. наше [руководство по kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Если `past_key_values` не переданы, по умолчанию будет инициализирован [DynamicCache](/docs/transformers/main/ru/internal/generation_utils#transformers.DynamicCache). Модель будет выводить тот же формат кэша, который был передан на вход. Если используются `past_key_values`, ожидается, что пользователь передаст только необработанные `input_ids` (те, для которых не заданы их прошлые состояния ключей и значений в этой модели) с формой `(batch_size, unprocessed_length)` вместо всех `input_ids` с формой `(batch_size, sequence_length)`. use_cache (`bool`, *необязательный*) : Если установлено в `True`, состояния ключей и значений `past_key_values` возвращаются и могут использоваться для ускорения декодирования (см. `past_key_values`). **Возвращает:** [BaseModelOutputWithPast](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) или `tuple(torch.Tensor)` [BaseModelOutputWithPast](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([GPTNeoXConfig](/docs/transformers/main/ru/model_doc/gpt_neox#transformers.GPTNeoXConfig)) и входных данных. Метод forward модели [GPTNeoXModel](/docs/transformers/main/ru/model_doc/gpt_neox#transformers.GPTNeoXModel) переопределяет специальный метод `__call__`. Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует. - **last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`) -- Последовательность скрытых состояний на выходе последнего слоя модели. Если используется `past_key_values`, выводится только последнее скрытое состояние последовательностей формы `(batch_size, 1, hidden_size)`. - **past_key_values** (`Cache`, *необязательный*, возвращается при передаче `use_cache=True` или когда `config.use_cache=True`) -- это экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache). Подробнее см. в нашем [руководстве по кэшированию kv](https://huggingface.co/docs/transformers/en/kv_cache). Содержит предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и, при необходимости, если `config.is_encoder_decoder=True`, в блоках кросс-внимания), которые можно использовать (см. входной параметр `past_key_values`) для ускорения последовательного декодирования. - **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 в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания. ## GPTNeoXForCausalLM[[transformers.GPTNeoXForCausalLM]] #### transformers.GPTNeoXForCausalLM[[transformers.GPTNeoXForCausalLM]] ```python transformers.GPTNeoXForCausalLM(config: GPTNeoXConfig) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gpt_neox/modeling_gpt_neox.py#L376) **Параметры:** config ([GPTNeoXConfig](/docs/transformers/main/ru/model_doc/gpt_neox#transformers.GPTNeoXConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. Модель GPTNeoX с головкой `language modeling` для дообучения CLM. Эта модель наследуется от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса. Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением. #### forward[[transformers.GPTNeoXForCausalLM.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs: *) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gpt_neox/modeling_gpt_neox.py#L396) **Параметры:** input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/main/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/main/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) 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` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели. past_key_values (`~cache_utils.Cache`, *необязательный*) : Предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и кросс-внимания), которые можно использовать для ускорения последовательного декодирования. Обычно это `past_key_values`, возвращаемые моделью на предыдущем этапе декодирования, когда `use_cache=True` или `config.use_cache=True`. В качестве входного значения допускается только экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache), см. наше [руководство по kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Если `past_key_values` не переданы, по умолчанию будет инициализирован [DynamicCache](/docs/transformers/main/ru/internal/generation_utils#transformers.DynamicCache). Модель будет выводить тот же формат кэша, который был передан на вход. Если используются `past_key_values`, ожидается, что пользователь передаст только необработанные `input_ids` (те, для которых не заданы их прошлые состояния ключей и значений в этой модели) с формой `(batch_size, unprocessed_length)` вместо всех `input_ids` с формой `(batch_size, sequence_length)`. labels (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательный*) : Метки для вычисления потери языкового моделирования слева направо (предсказание следующего слова). Индексы должны находиться в диапазоне `[-100, 0, ..., config.vocab_size]` (см. docstring `input_ids`). Токены с индексами, установленными в `-100`, игнорируются (маскируются); потеря вычисляется только для токенов с метками в диапазоне `[0, ..., config.vocab_size]`. use_cache (`bool`, *необязательный*) : Если установлено в `True`, состояния ключей и значений `past_key_values` возвращаются и могут использоваться для ускорения декодирования (см. `past_key_values`). logits_to_keep (`Union[int, torch.Tensor]`, *необязательный*, по умолчанию `0`) : Если передано значение типа `int`, вычисляются logits для последних `logits_to_keep` токенов. Если передано `0`, logits вычисляются для всех `input_ids` (специальный случай). Для генерации нужны logits только последнего токена, и вычисление их только для этого токена позволяет сэкономить память, что становится весьма значимым для длинных последовательностей или большого размера словаря. Если передано значение типа `torch.Tensor`, оно должно быть одномерным и соответствовать индексам, которые нужно сохранить в измерении длины последовательности. Это полезно при использовании упакованного формата тензоров (одно измерение для batch и длины последовательности). **Возвращает:** [CausalLMOutputWithPast](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) или `tuple(torch.Tensor)` Объект [CausalLMOutputWithPast](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([GPTNeoXConfig](/docs/transformers/main/ru/model_doc/gpt_neox#transformers.GPTNeoXConfig)) и входных данных. Метод forward класса [GPTNeoXForCausalLM](/docs/transformers/main/ru/model_doc/gpt_neox#transformers.GPTNeoXForCausalLM) переопределяет специальный метод `__call__`. Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует. - **loss** (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если задан `labels`) -- Потеря языковой модели (для предсказания следующего токена). - **logits** (`torch.Tensor` формы `(batch_size, sequence_length, config.vocab_size)`) — Оценки предсказаний языковой модели (оценки для каждого токена словаря до применения SoftMax). - **past_key_values** (`Cache`, *необязательный*, возвращается при передаче `use_cache=True` или когда `config.use_cache=True`) -- это экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache). Подробнее см. в нашем [руководстве по кэшированию kv](https://huggingface.co/docs/transformers/en/kv_cache). Содержит предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания), которые можно использовать (см. вход `past_key_values`) для ускорения последовательного декодирования. - **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, GPTNeoXForCausalLM, GPTNeoXConfig >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("EleutherAI/gpt-neox-20b") >>> config = GPTNeoXConfig.from_pretrained("EleutherAI/gpt-neox-20b") >>> config.is_decoder = True >>> model = GPTNeoXForCausalLM.from_pretrained("EleutherAI/gpt-neox-20b", config=config) >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt") >>> outputs = model(**inputs) >>> prediction_logits = outputs.logits ``` ## GPTNeoXForQuestionAnswering[[transformers.GPTNeoXForQuestionAnswering]] #### transformers.GPTNeoXForQuestionAnswering[[transformers.GPTNeoXForQuestionAnswering]] ```python transformers.GPTNeoXForQuestionAnswering(config: GPTNeoXConfig) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gpt_neox/modeling_gpt_neox.py#L601) **Параметры:** config ([GPTNeoXConfig](/docs/transformers/main/ru/model_doc/gpt_neox#transformers.GPTNeoXConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. Трансформер Gpt Neox с головой для классификации пропусков (span classification) сверху для задач извлекающего вопросно-ответного типа, таких как SQuAD (линейный слой поверх выходных скрытых состояний для вычисления `span start logits` и `span end logits`). Эта модель наследуется от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса. Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением. #### forward[[transformers.GPTNeoXForQuestionAnswering.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, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gpt_neox/modeling_gpt_neox.py#L611) **Параметры:** input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/main/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/main/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`). Позиции вне последовательности не учитываются при вычислении функции потерь. **Возвращает:** [QuestionAnsweringModelOutput](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) или `tuple(torch.Tensor)` Объект [QuestionAnsweringModelOutput](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([GPTNeoXConfig](/docs/transformers/main/ru/model_doc/gpt_neox#transformers.GPTNeoXConfig)) и входных данных. Метод forward класса [GPTNeoXForQuestionAnswering](/docs/transformers/main/ru/model_doc/gpt_neox#transformers.GPTNeoXForQuestionAnswering) переопределяет специальный метод `__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, GPTNeoXForQuestionAnswering >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("EleutherAI/gpt-neox-20b") >>> model = GPTNeoXForQuestionAnswering.from_pretrained("EleutherAI/gpt-neox-20b") >>> 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) ... ``` ## GPTNeoXForSequenceClassification[[transformers.GPTNeoXForSequenceClassification]] #### transformers.GPTNeoXForSequenceClassification[[transformers.GPTNeoXForSequenceClassification]] ```python transformers.GPTNeoXForSequenceClassification(config: GPTNeoXConfig) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gpt_neox/modeling_gpt_neox.py#L474) **Параметры:** config ([GPTNeoXConfig](/docs/transformers/main/ru/model_doc/gpt_neox#transformers.GPTNeoXConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. Модель-трансформер GPTNeoX с головой для классификации последовательностей (линейный слой) наверху. [GPTNeoXForSequenceClassification](/docs/transformers/main/ru/model_doc/gpt_neox#transformers.GPTNeoXForSequenceClassification) использует последний токен для выполнения классификации, как и другие каузальные модели (например, GPT-1). Поскольку классификация выполняется по последнему токену, необходимо знать позицию последнего токена. Если в конфигурации определён `pad_token_id`, то в каждой строке находится последний токен, не являющийся токеном отсечки. Если `pad_token_id` не определён, просто берётся последнее значение в каждой строке батча. Поскольку при передаче `inputs_embeds` вместо `input_ids` невозможно угадать токены отсечки, выполняется то же самое (берётся последнее значение в каждой строке батча). Эта модель наследуется от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса. Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением. #### forward[[transformers.GPTNeoXForSequenceClassification.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gpt_neox/modeling_gpt_neox.py#L484) **Параметры:** input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/main/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/main/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) 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` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели. past_key_values (`~cache_utils.Cache`, *необязательный*) : Предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и кросс-внимания), которые можно использовать для ускорения последовательного декодирования. Обычно это `past_key_values`, возвращаемые моделью на предыдущем этапе декодирования, когда `use_cache=True` или `config.use_cache=True`. В качестве входного значения допускается только экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache), см. наше [руководство по kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Если `past_key_values` не переданы, по умолчанию будет инициализирован [DynamicCache](/docs/transformers/main/ru/internal/generation_utils#transformers.DynamicCache). Модель будет выводить тот же формат кэша, который был передан на вход. Если используются `past_key_values`, ожидается, что пользователь передаст только необработанные `input_ids` (те, для которых не заданы их прошлые состояния ключей и значений в этой модели) с формой `(batch_size, unprocessed_length)` вместо всех `input_ids` с формой `(batch_size, sequence_length)`. labels (`torch.LongTensor` формы `(batch_size,)`, *необязательный*) : Метки для вычисления функции потерь классификации/регрессии последовательности. Индексы должны находиться в диапазоне `[0, ..., config.num_labels - 1]`. Если `config.num_labels == 1`, вычисляется функция потерь регрессии (среднеквадратичная ошибка), если `config.num_labels > 1` — функция потерь классификации (кросс-энтропия). use_cache (`bool`, *необязательный*) : Если установлено в `True`, состояния ключей и значений `past_key_values` возвращаются и могут использоваться для ускорения декодирования (см. `past_key_values`). **Возвращает:** `SequenceClassifierOutputWithPast` или `tuple(torch.Tensor)` Объект `SequenceClassifierOutputWithPast` или кортеж из `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([GPTNeoXConfig](/docs/transformers/main/ru/model_doc/gpt_neox#transformers.GPTNeoXConfig)) и входных данных. Метод forward класса [GPTNeoXForSequenceClassification](/docs/transformers/main/ru/model_doc/gpt_neox#transformers.GPTNeoXForSequenceClassification) переопределяет специальный метод `__call__`. Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует. - **loss** (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если задан `labels`) -- Потери классификации (или регрессии, если config.num_labels==1). - **logits** (`torch.Tensor` формы `(batch_size, config.num_labels)`) — Оценки классификации (или регрессии, если config.num_labels==1) до применения SoftMax. - **past_key_values** (`Cache`, *необязательный*, возвращается при передаче `use_cache=True` или когда `config.use_cache=True`) -- это экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache). Подробнее см. в нашем [руководстве по кэшированию kv](https://huggingface.co/docs/transformers/en/kv_cache). Содержит предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания), которые можно использовать (см. вход `past_key_values`) для ускорения последовательного декодирования. - **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, GPTNeoXForSequenceClassification >>> tokenizer = AutoTokenizer.from_pretrained("EleutherAI/gpt-neox-20b") >>> model = GPTNeoXForSequenceClassification.from_pretrained("EleutherAI/gpt-neox-20b") >>> 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 = GPTNeoXForSequenceClassification.from_pretrained("EleutherAI/gpt-neox-20b", 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, GPTNeoXForSequenceClassification >>> tokenizer = AutoTokenizer.from_pretrained("EleutherAI/gpt-neox-20b") >>> model = GPTNeoXForSequenceClassification.from_pretrained("EleutherAI/gpt-neox-20b", 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 = GPTNeoXForSequenceClassification.from_pretrained( ... "EleutherAI/gpt-neox-20b", 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 ``` ## GPTNeoXForTokenClassification[[transformers.GPTNeoXForTokenClassification]] #### transformers.GPTNeoXForTokenClassification[[transformers.GPTNeoXForTokenClassification]] ```python transformers.GPTNeoXForTokenClassification(config: GPTNeoXConfig) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gpt_neox/modeling_gpt_neox.py#L541) #### forward[[transformers.GPTNeoXForTokenClassification.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = 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, use_cache: bool | None = None, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gpt_neox/modeling_gpt_neox.py#L553) **Параметры:** input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/main/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids) past_key_values (`~cache_utils.Cache`, *необязательный*) : Предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и кросс-внимания), которые можно использовать для ускорения последовательного декодирования. Обычно это `past_key_values`, возвращаемые моделью на предыдущем этапе декодирования, когда `use_cache=True` или `config.use_cache=True`. В качестве входного значения допускается только экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache), см. наше [руководство по kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Если `past_key_values` не переданы, по умолчанию будет инициализирован [DynamicCache](/docs/transformers/main/ru/internal/generation_utils#transformers.DynamicCache). Модель будет выводить тот же формат кэша, который был передан на вход. Если используются `past_key_values`, ожидается, что пользователь передаст только необработанные `input_ids` (те, для которых не заданы их прошлые состояния ключей и значений в этой модели) с формой `(batch_size, unprocessed_length)` вместо всех `input_ids` с формой `(batch_size, sequence_length)`. 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]`. Если `config.num_labels == 1`, вычисляется функция потерь регрессии (среднеквадратичная ошибка), если `config.num_labels > 1` — функция потерь классификации (кросс-энтропия). use_cache (`bool`, *необязательный*) : Если установлено в `True`, состояния ключей и значений `past_key_values` возвращаются и могут использоваться для ускорения декодирования (см. `past_key_values`). **Возвращает:** [TokenClassifierOutput](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) или `tuple(torch.Tensor)` Объект [TokenClassifierOutput](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) или кортеж из `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([GPTNeoXConfig](/docs/transformers/main/ru/model_doc/gpt_neox#transformers.GPTNeoXConfig)) и входных данных. Метод forward класса [GPTNeoXForTokenClassification](/docs/transformers/main/ru/model_doc/gpt_neox#transformers.GPTNeoXForTokenClassification) переопределяет специальный метод `__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, GPTNeoXForTokenClassification >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("EleutherAI/gpt-neox-20b") >>> model = GPTNeoXForTokenClassification.from_pretrained("EleutherAI/gpt-neox-20b") >>> 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 ... >>> labels = predicted_token_class_ids >>> loss = model(**inputs, labels=labels).loss >>> round(loss.item(), 2) ... ```