> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.nvidia.com/nemo/automodel/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/nemo/automodel/_mcp/server.

# nemo_automodel.components.models.nemotron_parse.model

## Module Contents

### Classes

| Name                                                                                                                                    | Description                                                         |
| --------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------- |
| [`NemotronParseConfig`](#nemo_automodel-components-models-nemotron_parse-model-NemotronParseConfig)                                     | Configuration class for NemotronParse model.                        |
| [`NemotronParseDecoder`](#nemo_automodel-components-models-nemotron_parse-model-NemotronParseDecoder)                                   | Transformer decoder consisting of *config.decoder\_layers* layers.  |
| [`NemotronParseEncoderConfig`](#nemo_automodel-components-models-nemotron_parse-model-NemotronParseEncoderConfig)                       | Configuration class for NemotronParse vision encoder (RADIO-based). |
| [`NemotronParseForConditionalGeneration`](#nemo_automodel-components-models-nemotron_parse-model-NemotronParseForConditionalGeneration) | NemotronParse model for conditional generation tasks.               |
| [`NemotronParsePreTrainedModel`](#nemo_automodel-components-models-nemotron_parse-model-NemotronParsePreTrainedModel)                   | Abstract class to handle weights initialization.                    |
| [`NemotronParseTextConfig`](#nemo_automodel-components-models-nemotron_parse-model-NemotronParseTextConfig)                             | Configuration class for NemotronParse text decoder (mBART-based).   |
| [`RadioWithNeck`](#nemo_automodel-components-models-nemotron_parse-model-RadioWithNeck)                                                 | Vision encoder using RADIO model with custom neck.                  |

### Data

[`ModelClass`](#nemo_automodel-components-models-nemotron_parse-model-ModelClass)

### API

```python
class nemo_automodel.components.models.nemotron_parse.model.NemotronParseConfig(
    encoder: typing.Optional[dict] = None,
    decoder: typing.Optional[dict] = None,
    tie_word_embeddings: bool = False,
    decoder_start_token_id: int = 2,
    pad_token_id: int = 1,
    eos_token_id: int = 2,
    bos_token_id: int = 0,
    image_size: typing.List[int] = None,
    is_encoder_decoder: bool = True,
    max_sequence_length: int = 9000,
    kwargs = {}
)
```

**Bases:** `PretrainedConfig`

Configuration class for NemotronParse model.

```python
nemo_automodel.components.models.nemotron_parse.model.NemotronParseConfig.to_dict()
```

```python
class nemo_automodel.components.models.nemotron_parse.model.NemotronParseDecoder(
    config: transformers.models.mbart.modeling_mbart.MBartConfig,
    embed_tokens: typing.Optional[torch.nn.Embedding] = None
)
```

**Bases:** `MBartPreTrainedModel`

Transformer decoder consisting of *config.decoder\_layers* layers.

```python
nemo_automodel.components.models.nemotron_parse.model.NemotronParseDecoder.forward(
    input_ids: typing.Optional[torch.LongTensor] = None,
    attention_mask: typing.Optional[torch.Tensor] = None,
    encoder_hidden_states: typing.Optional[torch.FloatTensor] = None,
    encoder_attention_mask: typing.Optional[torch.LongTensor] = None,
    past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None,
    inputs_embeds: typing.Optional[torch.FloatTensor] = None,
    use_cache: typing.Optional[bool] = None,
    output_attentions: typing.Optional[bool] = None,
    output_hidden_states: typing.Optional[bool] = None,
    return_dict: typing.Optional[bool] = None
) -> typing.Union[typing.Tuple, transformers.models.mbart.modeling_mbart.BaseModelOutputWithPastAndCrossAttentions]
```

```python
nemo_automodel.components.models.nemotron_parse.model.NemotronParseDecoder.get_input_embeddings()
```

```python
nemo_automodel.components.models.nemotron_parse.model.NemotronParseDecoder.set_input_embeddings(
    value
)
```

```python
class nemo_automodel.components.models.nemotron_parse.model.NemotronParseEncoderConfig(
    patch_size: int = 16,
    max_resolution: int = 2048,
    preferred_resolution: typing.List[int] = None,
    torch_dtype: str = 'bfloat16',
    kwargs = {}
)
```

**Bases:** `PretrainedConfig`

Configuration class for NemotronParse vision encoder (RADIO-based).

```python
class nemo_automodel.components.models.nemotron_parse.model.NemotronParseForConditionalGeneration(
    config: nemo_automodel.components.models.nemotron_parse.model.NemotronParseConfig,
    loss_fn = None,
    kwargs = {}
)
```

**Bases:** [HFCheckpointingMixin](/nemo-automodel/nemo_automodel/components/models/common/hf_checkpointing_mixin#nemo_automodel-components-models-common-hf_checkpointing_mixin-HFCheckpointingMixin), [NemotronParsePreTrainedModel](#nemo_automodel-components-models-nemotron_parse-model-NemotronParsePreTrainedModel), `GenerationMixin`

NemotronParse model for conditional generation tasks.

```python
nemo_automodel.components.models.nemotron_parse.model.NemotronParseForConditionalGeneration._reorder_cache(
    past_key_values,
    beam_idx
)
```

```python
nemo_automodel.components.models.nemotron_parse.model.NemotronParseForConditionalGeneration.forward(
    pixel_values: typing.Optional[torch.FloatTensor] = None,
    decoder_input_ids: typing.Optional[torch.LongTensor] = None,
    decoder_attention_mask: typing.Optional[torch.BoolTensor] = None,
    encoder_outputs: typing.Optional[typing.Tuple[torch.FloatTensor]] = None,
    past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None,
    decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None,
    labels: typing.Optional[torch.LongTensor] = None,
    use_cache: typing.Optional[bool] = None,
    output_attentions: typing.Optional[bool] = None,
    output_hidden_states: typing.Optional[bool] = None,
    return_dict: typing.Optional[bool] = None,
    logits_to_keep: typing.Union[int, torch.Tensor] = 0,
    kwargs = {}
) -> typing.Union[typing.Tuple[torch.FloatTensor], transformers.modeling_outputs.Seq2SeqLMOutput]
```

```python
nemo_automodel.components.models.nemotron_parse.model.NemotronParseForConditionalGeneration.get_decoder()
```

```python
nemo_automodel.components.models.nemotron_parse.model.NemotronParseForConditionalGeneration.get_encoder()
```

```python
nemo_automodel.components.models.nemotron_parse.model.NemotronParseForConditionalGeneration.get_input_embeddings()
```

```python
nemo_automodel.components.models.nemotron_parse.model.NemotronParseForConditionalGeneration.get_output_embeddings()
```

```python
nemo_automodel.components.models.nemotron_parse.model.NemotronParseForConditionalGeneration.prepare_decoder_input_ids_from_labels(
    labels: torch.Tensor
)
```

```python
nemo_automodel.components.models.nemotron_parse.model.NemotronParseForConditionalGeneration.set_input_embeddings(
    value
)
```

```python
nemo_automodel.components.models.nemotron_parse.model.NemotronParseForConditionalGeneration.set_output_embeddings(
    new_embeddings
)
```

```python
class nemo_automodel.components.models.nemotron_parse.model.NemotronParsePreTrainedModel()
```

**Bases:** `PreTrainedModel`

Abstract class to handle weights initialization.

```python
nemo_automodel.components.models.nemotron_parse.model.NemotronParsePreTrainedModel._init_weights(
    module
)
```

```python
class nemo_automodel.components.models.nemotron_parse.model.NemotronParseTextConfig(
    vocab_size: int = 250027,
    d_model: int = 1024,
    encoder_layers: int = 12,
    decoder_layers: int = 12,
    encoder_attention_heads: int = 16,
    decoder_attention_heads: int = 16,
    decoder_ffn_dim: int = 4096,
    encoder_ffn_dim: int = 4096,
    activation_function: str = 'gelu',
    dropout: float = 0.1,
    attention_dropout: float = 0.0,
    activation_dropout: float = 0.0,
    classifier_dropout: float = 0.0,
    init_std: float = 0.02,
    encoder_layerdrop: float = 0.0,
    decoder_layerdrop: float = 0.0,
    scale_embedding: bool = False,
    use_cache: bool = True,
    num_labels: int = 3,
    forced_eos_token_id: int = 2,
    pad_token_id: int = 1,
    bos_token_id: int = 0,
    eos_token_id: int = 2,
    decoder_start_token_id: int = 2,
    add_cross_attention: bool = True,
    is_decoder: bool = True,
    max_sequence_length: int = 9000,
    kwargs = {}
)
```

**Bases:** `PretrainedConfig`

Configuration class for NemotronParse text decoder (mBART-based).

```python
class nemo_automodel.components.models.nemotron_parse.model.RadioWithNeck(
    config
)
```

**Bases:** `Module`

Vision encoder using RADIO model with custom neck.

```python
nemo_automodel.components.models.nemotron_parse.model.RadioWithNeck.forward(
    pixel_values,
    output_attentions = False,
    output_hidden_states = False,
    return_dict = False,
    kwargs = {}
)
```

```python
nemo_automodel.components.models.nemotron_parse.model.ModelClass = NemotronParseForConditionalGeneration
```