# NemotronH

[NemotronH](https://huggingface.co/papers/2504.03624) — это гибридная архитектура, сочетающая слои внимания и слои пространства состояний для эффективного моделирования языка с длинным контекстом. Она чередует блоки Mamba2 и трансформерные блоки, используя фиксированное соотношение для баланса между выразительностью и обработкой последовательностей за линейное время.

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

```python
from transformers import pipeline

pipe = pipeline(
    task="text-generation",
    model="nvidia/Nemotron-H-8B-Reasoning-128K",
)
pipe("Plants create energy through a process known as")
```

```python
from transformers import AutoModelForCausalLM, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("nvidia/Nemotron-H-8B-Reasoning-128K")
model = AutoModelForCausalLM.from_pretrained(
    "nvidia/Nemotron-H-8B-Reasoning-128K",
    device_map="auto",
)
input_ids = tokenizer("Plants create energy through a process known as", return_tensors="pt").to(model.device)

output = model.generate(**input_ids, max_new_tokens=50)
print(tokenizer.decode(output[0], skip_special_tokens=True))
```

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

- Используйте левое выравнивание (left padding) для пакетной генерации. См. [Сторона выравнивания](../llm_tutorial#padding-side).

## NemotronHConfig[[transformers.NemotronHConfig]]

#### transformers.NemotronHConfig[[transformers.NemotronHConfig]]

```python
transformers.NemotronHConfig(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 = 131072, hidden_size: int = 4096, layers_block_type: list[str] | None = None, tie_word_embeddings: bool = False, use_cache: bool = True, num_logits_to_keep: int = 1, pad_token_id: int | None = 0, bos_token_id: int | None = 1, eos_token_id: int | list[int] | None = 2, num_attention_heads: int = 32, num_key_value_heads: int = 8, head_dim: int = 128, max_position_embeddings: int = 4096, attention_bias: bool = False, attention_dropout: float | int = 0.0, sliding_window: int | None = None, intermediate_size: int = 21504, mlp_hidden_act: str = 'relu2', mlp_bias: bool = False, use_mamba_kernels: bool = True, ssm_state_size: int = 128, mamba_num_heads: int = 128, mamba_head_dim: int = 64, mamba_hidden_act: str = 'silu', n_groups: int = 8, conv_kernel: int = 4, expand: int = 2, time_step_min: float = 0.001, time_step_max: float = 0.1, time_step_limit: list[float] | tuple[float, ...] = (0.0, inf), time_step_floor: float = 0.0001, use_conv_bias: bool = True, chunk_size: int = 128, mamba_proj_bias: bool = False, mamba_ssm_cache_dtype: str = 'float32', n_routed_experts: int = 8, output_router_logits: bool = False, n_shared_experts: int = 1, moe_intermediate_size: int = 7688, moe_shared_expert_intermediate_size: int = 7688, moe_latent_size: int | None = None, moe_shared_expert_overlap: bool = True, num_experts_per_tok: int = 2, routed_scaling_factor: float | int = 1.0, n_group: int = 1, topk_group: int = 1, norm_topk_prob: bool = True, num_nextn_predict_layers: int = 0, mtp_layers_block_type: list[str] | None = None, use_bias: bool = False, initializer_range: float = 0.02, layer_norm_epsilon: float = 1e-05, residual_in_fp32: bool = False, hidden_dropout: float | int = 0.0, rescale_prenorm_residual: bool = True)
```

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

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

vocab_size (`int`, *необязательный*, по умолчанию `131072`) : Размер словаря модели. Определяет количество различных токенов, которые могут быть представлены в `input_ids`.

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

layers_block_type (`list`, *необязательный*) : Явный список типов слоёв для каждого слоя. Каждый элемент должен быть одним из: "mlp", "linear_attention", "full_attention" или "moe". Количество слоёв определяется длиной этого списка.

tie_word_embeddings (`bool`, *необязательный*, по умолчанию `False`) : Связывать ли веса эмбеддингов согласно отображению `tied_weights_keys` модели.

use_cache (`bool`, *необязательный*, по умолчанию `True`) : Следует ли модели возвращать последние значения внимания key/values (не используется во всех моделях). Актуально только при `config.is_decoder=True` или если модель является генеративной моделью только с декодером.

num_logits_to_keep (`int`, *optional*, по умолчанию 1) : Количество prompt logits, которые вычисляются во время генерации. Если `None`, будут вычислены все logits.

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

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

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

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

num_key_value_heads (`int`, *optional*, по умолчанию `8`) : Это количество ключевых и value-голов, которое следует использовать для реализации Grouped Query Attention. Если `num_key_value_heads=num_attention_heads`, модель будет использовать Multi Head Attention (MHA), если `num_key_value_heads=1` — Multi Query Attention (MQA), в противном случае используется GQA. При конвертации multi-head checkpoint в GQA checkpoint каждая группа ключевых и value-голов должна быть построена путем усреднения (meanpooling) всех исходных голов в этой группе. Подробнее см. в [этой статье](https://huggingface.co/papers/2305.13245). Если значение не указано, по умолчанию используется `num_attention_heads`.

head_dim (`int`, *необязательный*, по умолчанию `128`) : Размер измерения головы внимания. Если None, по умолчанию будет hidden_size // num_attention_heads

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

attention_bias (`bool`, *необязательный*, по умолчанию `False`) : Использовать ли смещение (bias) в слоях проекции запроса, ключа, значения и вывода при само-внимании.

attention_dropout (`Union[float, int]`, *необязательный*, по умолчанию `0.0`) : Коэффициент dropout для вероятностей внимания.

sliding_window (`int`, *optional*) : Размер окна скользящего внимания. Если `None`, скользящее окно не применяется.

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

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

mlp_bias (`bool`, *необязательный*, по умолчанию `False`) : Использовать ли смещение (bias) в слоях up_proj, down_proj и gate_proj в слоях MLP.

use_mamba_kernels (`bool`, *необязательный*, по умолчанию `True`) : Устаревший параметр, не оказывает влияния. Быстрые ядра Mamba используются автоматически, когда доступны.

ssm_state_size (`int`, *optional*, по умолчанию 128) : Размерность латентов пространства состояний mamba.

mamba_num_heads (`int`, *необязательный*, по умолчанию `128`) : Количество mamba-голов, используемых в реализации v2.

mamba_head_dim (`int`, *необязательный*, по умолчанию `64`) : Размер размерности встраивания заголовка

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

n_groups (`int`, *optional*, по умолчанию 8) : Количество групп для матриц эволюции в слоях Mamba.

conv_kernel (`int`, *optional*, по умолчанию `4`) : Размер свёрточного ядра.

expand (`int`, *optional*, по умолчанию 2) : Коэффициент расширения, используемый для определения промежуточного размера в слоях Mamba.

time_step_min (`float`, *необязательный*, по умолчанию `0.001`) : Минимальное значение `time_step`, используемое для ограничения `dt_proj.bias`.

time_step_max (`float`, *необязательный*, по умолчанию `0.1`) : Максимальное значение `time_step`, используемое для ограничения `dt_proj.bias`.

time_step_limit (`Union[list[float], tuple[float, ...]]`, *необязательный*, по умолчанию `(0.0, inf)`) : Допустимый диапазон значений шага времени для ограничения.

time_step_floor (`float`, *необязательный*, по умолчанию `0.0001`) : Минимально допустимое значение дискретного шага времени delta после активации softplus.

use_conv_bias (`bool`, *необязательный*, по умолчанию `True`) : Использовать ли смещение (bias) в слое свёртки блока Mamba mixer.

chunk_size (`int`, *optional*, по умолчанию 128) : Размер блоков, из которых будет состоять последовательность в слоях Mamba.

mamba_proj_bias (`bool`, *необязательный*, по умолчанию `False`) : Флаг, указывающий, следует ли использовать смещение (bias) во входных и выходных проекциях (["in_proj", "out_proj"]) блока mamba mixer

mamba_ssm_cache_dtype (`str`, *необязательный*, по умолчанию `"float32"`) : Тип данных для состояний кэша Samba SSM.

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

output_router_logits (`bool`, *необязательный*, по умолчанию `False`) : Нужно ли модели возвращать логиты роутера. Включение этого параметра также позволит модели выводить вспомогательную потерю, включая потерю балансировки нагрузки и z-потерю роутера.

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

moe_intermediate_size (`int`, *необязательный*, по умолчанию `7688`) : Промежуточный размер MLP маршрутизированных экспертов.

moe_shared_expert_intermediate_size (`int`, *optional*, по умолчанию 7688) : Размерность представлений MLP в общих экспертах.

moe_latent_size (`int`, *optional*) : Размер латентного пространства для проекций экспертов MoE. Если `None`, используется `hidden_size`.

moe_shared_expert_overlap (`bool`, *необязательный*, по умолчанию `True`) : Пересекаются ли общие эксперты с маршрутизируемыми экспертами.

num_experts_per_tok (`int`, *optional*, по умолчанию `2`) : Количество экспертов, к которым маршрутизируется каждый токен. Это значение top-k для маршрутизации по выбору токена.

routed_scaling_factor (`Union[float, int]`, *необязательный*, по умолчанию `1.0`) : Коэффициент масштабирования или маршрутизированные эксперты.

n_group (`int`, *необязательный*, по умолчанию 1) : Количество групп для маршрутизации экспертов.

topk_group (`int`, *optional*, по умолчанию `1`) : Количество выбранных групп для каждого токена (для каждого токена, чтобы выбранные эксперты находились только в пределах `topk_group` групп).

norm_topk_prob (`bool`, *необязательный*, по умолчанию `True`) : Нужно ли нормализовать веса маршрутизированных экспертов.

num_nextn_predict_layers (`int`, *optional*, по умолчанию 0) : Количество дополнительных слоёв для предсказания нескольких токенов. Если равно 0, предсказание нескольких токенов отключено.

mtp_layers_block_type (`list`, *необязательный*, по умолчанию `['full_attention', 'moe']`) : Явный список типов слоёв для слоёв много-токенного предсказания, когда `num_nextn_predict_layers` > 0.

use_bias (`bool`, *необязательный*, по умолчанию `False`) : Использовать ли смещение (bias) в модели.

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

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

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

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

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

Это класс конфигурации для хранения настроек модели NemotronHModel. Он используется для создания модели Nemotron H в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации модели [nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16](https://huggingface.co/nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16)

Объекты конфигурации наследуются от [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 NemotronHModel, NemotronHConfig

>>> # Initializing a NemotronH configuration
>>> configuration = NemotronHConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = NemotronHModel(configuration)

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

#### validate_layer_type[[transformers.NemotronHConfig.validate_layer_type]]

```python
validate_layer_type()
```

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

Проверьте список layers_block_type.

## NemotronHModel[[transformers.NemotronHModel]]

#### transformers.NemotronHModel[[transformers.NemotronHModel]]

```python
transformers.NemotronHModel(config: NemotronHConfig)
```

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

#### forward[[transformers.NemotronHModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, use_cache: bool | None = None, attention_mask: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

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

## NemotronHForCausalLM[[transformers.NemotronHForCausalLM]]

#### transformers.NemotronHForCausalLM[[transformers.NemotronHForCausalLM]]

```python
transformers.NemotronHForCausalLM(config: NemotronHConfig)
```

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

#### forward[[transformers.NemotronHForCausalLM.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = 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/v5.23.0/src/transformers/models/nemotron_h/modeling_nemotron_h.py#L1169)

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

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)

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

past_key_values (`~cache_utils.Cache`, *необязательный*) : Предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и кросс-внимания), которые можно использовать для ускорения последовательного декодирования. Обычно это `past_key_values`, возвращаемые моделью на предыдущем этапе декодирования, когда `use_cache=True` или `config.use_cache=True`. В качестве входного значения допускается только экземпляр [Cache](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.Cache), см. наше [руководство по kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Если `past_key_values` не переданы, по умолчанию будет инициализирован [DynamicCache](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.DynamicCache). Модель будет выводить тот же формат кэша, который был передан на вход. Если используются `past_key_values`, ожидается, что пользователь передаст только необработанные `input_ids` (те, для которых не заданы их прошлые состояния ключей и значений в этой модели) с формой `(batch_size, unprocessed_length)` вместо всех `input_ids` с формой `(batch_size, sequence_length)`.

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

labels (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательный*) : Метки для вычисления потерь каузального языкового моделирования. Индексы должны находиться в диапазоне `[-100, 0, ..., config.vocab_size]` (см. docstring для `input_ids`). Токены с индексами, установленными в `-100`, игнорируются (маскируются); потери вычисляются только для токенов с метками в диапазоне `[0, ..., config.vocab_size]`. Метки **внутренне сдвигаются**, так что `labels[..., 1:]` используются для предсказания `logits[..., :-1, :]`. Передавайте несдвинутые метки, соответствующие `input_ids` (т. е. `labels = input_ids`). Не **сдвигайте** метки самостоятельно перед передачей. Если метки уже сдвинуты (например, при параллелизме последовательностей), передайте их как аргумент `shift_labels`, и они будут использованы как есть. `labels` всё равно необходимо передать для вычисления потерь.

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 и длины последовательности).

**Возвращает:** `MoeCausalLMOutputWithPast` или `tuple(torch.Tensor)`

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

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

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

- **loss** (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если задан `labels`) -- Потеря языковой модели (для предсказания следующего токена).
- **logits** (`torch.Tensor` формы `(batch_size, sequence_length, config.vocab_size)`) — Оценки предсказаний языковой модели (оценки для каждого токена словаря до применения SoftMax).
- **aux_loss** (`torch.Tensor`, *необязательный*, возвращается при передаче `output_router_logits=True` или при `config.output_router_logits=True`, если модель обучает свой роутер с потерей балансировки нагрузки) -- Вспомогательная потеря балансировки нагрузки для разреженных модулей. Модели, которые балансируют своих экспертов с помощью смещения роутера (DeepSeek-V3 и архитектуры, производные от него), возвращают здесь `None`, при этом по-прежнему возвращая `router_logits`.
- **router_logits** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_router_logits=True` или когда `config.output_router_logits=True`) -- Кортеж `torch.Tensor` (по одному для каждого разреженного слоя) формы `(batch_size * sequence_length, num_experts)`.

  Сырые логиты маршрутизатора, вычисленные маршрутизаторами MoE. Их можно использовать для вычисления функции потерь балансировки нагрузки или для анализа того, как токены распределяются по экспертам.
- **past_key_values** (`Cache`, *необязательный*, возвращается при передаче `use_cache=True` или когда `config.use_cache=True`) -- это экземпляр [Cache](/docs/transformers/v5.23.0/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, NemotronHForCausalLM

>>> model = NemotronHForCausalLM.from_pretrained("Zyphra/NemotronH-7B-v1")
>>> tokenizer = AutoTokenizer.from_pretrained("Zyphra/NemotronH-7B-v1")

>>> prompt = "Hey, are you conscious? Can you talk to me?"
>>> inputs = tokenizer(prompt, return_tensors="pt")

>>> # Generate
>>> generate_ids = model.generate(inputs.input_ids, max_length=30)
>>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"Hey, are you conscious? Can you talk to me?\nI'm not conscious, but I can talk to you."
```