Skip to content

xlm_roberta

mindnlp.transformers.models.xlm_roberta.configuration_xlm_roberta

XLM-RoBERTa configuration

mindnlp.transformers.models.xlm_roberta.configuration_xlm_roberta.XLMRobertaConfig

Bases: PretrainedConfig

This is the configuration class to store the configuration of a [XLMRobertaModel] or a [TFXLMRobertaModel]. It is used to instantiate a XLM-RoBERTa model according to the specified arguments, defining the model architecture. Instantiating a configuration with the defaults will yield a similar configuration to that of the XLMRoBERTa xlm-roberta-base architecture.

Configuration objects inherit from [PretrainedConfig] and can be used to control the model outputs. Read the documentation from [PretrainedConfig] for more information.

PARAMETER DESCRIPTION
vocab_size

Vocabulary size of the XLM-RoBERTa model. Defines the number of different tokens that can be represented by the inputs_ids passed when calling [XLMRobertaModel] or [TFXLMRobertaModel].

TYPE: `int`, *optional*, defaults to 30522 DEFAULT: 30522

hidden_size

Dimensionality of the encoder layers and the pooler layer.

TYPE: `int`, *optional*, defaults to 768 DEFAULT: 768

num_hidden_layers

Number of hidden layers in the Transformer encoder.

TYPE: `int`, *optional*, defaults to 12 DEFAULT: 12

num_attention_heads

Number of attention heads for each attention layer in the Transformer encoder.

TYPE: `int`, *optional*, defaults to 12 DEFAULT: 12

intermediate_size

Dimensionality of the "intermediate" (often named feed-forward) layer in the Transformer encoder.

TYPE: `int`, *optional*, defaults to 3072 DEFAULT: 3072

hidden_act

The non-linear activation function (function or string) in the encoder and pooler. If string, "gelu", "relu", "silu" and "gelu_new" are supported.

TYPE: `str` or `Callable`, *optional*, defaults to `"gelu"` DEFAULT: 'gelu'

hidden_dropout_prob

The dropout probability for all fully connected layers in the embeddings, encoder, and pooler.

TYPE: `float`, *optional*, defaults to 0.1 DEFAULT: 0.1

attention_probs_dropout_prob

The dropout ratio for the attention probabilities.

TYPE: `float`, *optional*, defaults to 0.1 DEFAULT: 0.1

max_position_embeddings

The maximum sequence length that this model might ever be used with. Typically set this to something large just in case (e.g., 512 or 1024 or 2048).

TYPE: `int`, *optional*, defaults to 512 DEFAULT: 512

type_vocab_size

The vocabulary size of the token_type_ids passed when calling [XLMRobertaModel] or [TFXLMRobertaModel].

TYPE: `int`, *optional*, defaults to 2 DEFAULT: 2

initializer_range

The standard deviation of the truncated_normal_initializer for initializing all weight matrices.

TYPE: `float`, *optional*, defaults to 0.02 DEFAULT: 0.02

layer_norm_eps

The epsilon used by the layer normalization layers.

TYPE: `float`, *optional*, defaults to 1e-12 DEFAULT: 1e-12

position_embedding_type

Type of position embedding. Choose one of "absolute", "relative_key", "relative_key_query". For positional embeddings use "absolute". For more information on "relative_key", please refer to Self-Attention with Relative Position Representations (Shaw et al.). For more information on "relative_key_query", please refer to Method 4 in Improve Transformer Models with Better Relative Position Embeddings (Huang et al.).

TYPE: `str`, *optional*, defaults to `"absolute"` DEFAULT: 'absolute'

is_decoder

Whether the model is used as a decoder or not. If False, the model is used as an encoder.

TYPE: `bool`, *optional*, defaults to `False`

use_cache

Whether or not the model should return the last key/values attentions (not used by all models). Only relevant if config.is_decoder=True.

TYPE: `bool`, *optional*, defaults to `True` DEFAULT: True

classifier_dropout

The dropout ratio for the classification head.

TYPE: `float`, *optional* DEFAULT: None

Example 
>>> from transformers import XLMRobertaConfig, XLMRobertaModel
...
>>> # Initializing a XLM-RoBERTa xlm-roberta-base style configuration
>>> configuration = XLMRobertaConfig()
...
>>> # Initializing a model (with random weights) from the xlm-roberta-base style configuration
>>> model = XLMRobertaModel(configuration)
...
>>> # Accessing the model configuration
>>> configuration = model.config
Source code in mindnlp/transformers/models/xlm_roberta/configuration_xlm_roberta.py 
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
class XLMRobertaConfig(PretrainedConfig):
    r"""
    This is the configuration class to store the configuration of a [`XLMRobertaModel`] or a [`TFXLMRobertaModel`]. It
    is used to instantiate a XLM-RoBERTa model according to the specified arguments, defining the model architecture.
    Instantiating a configuration with the defaults will yield a similar configuration to that of the XLMRoBERTa
    [xlm-roberta-base](https://hf-mirror.com/xlm-roberta-base) architecture.

    Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
    documentation from [`PretrainedConfig`] for more information.


    Args:
        vocab_size (`int`, *optional*, defaults to 30522):
            Vocabulary size of the XLM-RoBERTa model. Defines the number of different tokens that can be represented by
            the `inputs_ids` passed when calling [`XLMRobertaModel`] or [`TFXLMRobertaModel`].
        hidden_size (`int`, *optional*, defaults to 768):
            Dimensionality of the encoder layers and the pooler layer.
        num_hidden_layers (`int`, *optional*, defaults to 12):
            Number of hidden layers in the Transformer encoder.
        num_attention_heads (`int`, *optional*, defaults to 12):
            Number of attention heads for each attention layer in the Transformer encoder.
        intermediate_size (`int`, *optional*, defaults to 3072):
            Dimensionality of the "intermediate" (often named feed-forward) layer in the Transformer encoder.
        hidden_act (`str` or `Callable`, *optional*, defaults to `"gelu"`):
            The non-linear activation function (function or string) in the encoder and pooler. If string, `"gelu"`,
            `"relu"`, `"silu"` and `"gelu_new"` are supported.
        hidden_dropout_prob (`float`, *optional*, defaults to 0.1):
            The dropout probability for all fully connected layers in the embeddings, encoder, and pooler.
        attention_probs_dropout_prob (`float`, *optional*, defaults to 0.1):
            The dropout ratio for the attention probabilities.
        max_position_embeddings (`int`, *optional*, defaults to 512):
            The maximum sequence length that this model might ever be used with. Typically set this to something large
            just in case (e.g., 512 or 1024 or 2048).
        type_vocab_size (`int`, *optional*, defaults to 2):
            The vocabulary size of the `token_type_ids` passed when calling [`XLMRobertaModel`] or
            [`TFXLMRobertaModel`].
        initializer_range (`float`, *optional*, defaults to 0.02):
            The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
        layer_norm_eps (`float`, *optional*, defaults to 1e-12):
            The epsilon used by the layer normalization layers.
        position_embedding_type (`str`, *optional*, defaults to `"absolute"`):
            Type of position embedding. Choose one of `"absolute"`, `"relative_key"`, `"relative_key_query"`. For
            positional embeddings use `"absolute"`. For more information on `"relative_key"`, please refer to
            [Self-Attention with Relative Position Representations (Shaw et al.)](https://arxiv.org/abs/1803.02155).
            For more information on `"relative_key_query"`, please refer to *Method 4* in [Improve Transformer Models
            with Better Relative Position Embeddings (Huang et al.)](https://arxiv.org/abs/2009.13658).
        is_decoder (`bool`, *optional*, defaults to `False`):
            Whether the model is used as a decoder or not. If `False`, the model is used as an encoder.
        use_cache (`bool`, *optional*, defaults to `True`):
            Whether or not the model should return the last key/values attentions (not used by all models). Only
            relevant if `config.is_decoder=True`.
        classifier_dropout (`float`, *optional*):
            The dropout ratio for the classification head.

    Example:
        ```python
        >>> from transformers import XLMRobertaConfig, XLMRobertaModel
        ...
        >>> # Initializing a XLM-RoBERTa xlm-roberta-base style configuration
        >>> configuration = XLMRobertaConfig()
        ...
        >>> # Initializing a model (with random weights) from the xlm-roberta-base style configuration
        >>> model = XLMRobertaModel(configuration)
        ...
        >>> # Accessing the model configuration
        >>> configuration = model.config
        ```
    """
    model_type = "xlm-roberta"

    def __init__(
        self,
        vocab_size=30522,
        hidden_size=768,
        num_hidden_layers=12,
        num_attention_heads=12,
        intermediate_size=3072,
        hidden_act="gelu",
        hidden_dropout_prob=0.1,
        attention_probs_dropout_prob=0.1,
        max_position_embeddings=512,
        type_vocab_size=2,
        initializer_range=0.02,
        layer_norm_eps=1e-12,
        pad_token_id=1,
        bos_token_id=0,
        eos_token_id=2,
        position_embedding_type="absolute",
        use_cache=True,
        classifier_dropout=None,
        **kwargs,
    ):
        """
        The __init__ method initializes an instance of the XLMRobertaConfig class.

        Args:
            self: The instance of the class.
            vocab_size (int): The size of the vocabulary.
            hidden_size (int): The size of the hidden layers.
            num_hidden_layers (int): The number of hidden layers.
            num_attention_heads (int): The number of attention heads.
            intermediate_size (int): The size of the intermediate layer in the transformer encoder.
            hidden_act (str): The activation function for the hidden layers.
            hidden_dropout_prob (float): The dropout probability for the hidden layers.
            attention_probs_dropout_prob (float): The dropout probability for the attention probabilities.
            max_position_embeddings (int): The maximum position for positional embeddings.
            type_vocab_size (int): The size of the type vocabulary.
            initializer_range (float): The range for weight initialization.
            layer_norm_eps (float): The epsilon value for layer normalization.
            pad_token_id (int): The id for padding tokens.
            bos_token_id (int): The id for the beginning of sequence tokens.
            eos_token_id (int): The id for the end of sequence tokens.
            position_embedding_type (str): The type of position embedding to use.
            use_cache (bool): Whether to use cache for intermediate computations.
            classifier_dropout (float): The dropout probability for the classifier. Default is None.

        Returns:
            None.

        Raises:
            ValueError: If vocab_size, hidden_size, num_hidden_layers, num_attention_heads, intermediate_size,
                max_position_embeddings, type_vocab_size are not positive integers.
            ValueError: If hidden_dropout_prob, attention_probs_dropout_prob, initializer_range, layer_norm_eps,
                classifier_dropout are not in the range [0.0, 1.0].
            ValueError: If position_embedding_type is not 'absolute' or 'relative'.
            ValueError: If pad_token_id, bos_token_id, eos_token_id are not non-negative integers.
            TypeError: If classifier_dropout is not a float or None.
        """
        super().__init__(pad_token_id=pad_token_id, bos_token_id=bos_token_id, eos_token_id=eos_token_id, **kwargs)

        self.vocab_size = vocab_size
        self.hidden_size = hidden_size
        self.num_hidden_layers = num_hidden_layers
        self.num_attention_heads = num_attention_heads
        self.hidden_act = hidden_act
        self.intermediate_size = intermediate_size
        self.hidden_dropout_prob = hidden_dropout_prob
        self.attention_probs_dropout_prob = attention_probs_dropout_prob
        self.max_position_embeddings = max_position_embeddings
        self.type_vocab_size = type_vocab_size
        self.initializer_range = initializer_range
        self.layer_norm_eps = layer_norm_eps
        self.position_embedding_type = position_embedding_type
        self.use_cache = use_cache
        self.classifier_dropout = classifier_dropout

mindnlp.transformers.models.xlm_roberta.configuration_xlm_roberta.XLMRobertaConfig.__init__(vocab_size=30522, hidden_size=768, num_hidden_layers=12, num_attention_heads=12, intermediate_size=3072, hidden_act='gelu', hidden_dropout_prob=0.1, attention_probs_dropout_prob=0.1, max_position_embeddings=512, type_vocab_size=2, initializer_range=0.02, layer_norm_eps=1e-12, pad_token_id=1, bos_token_id=0, eos_token_id=2, position_embedding_type='absolute', use_cache=True, classifier_dropout=None, **kwargs)

The init method initializes an instance of the XLMRobertaConfig class.

PARAMETER DESCRIPTION
self

The instance of the class.
vocab_size

The size of the vocabulary.

TYPE: int DEFAULT: 30522

hidden_size

The size of the hidden layers.

TYPE: int DEFAULT: 768

num_hidden_layers

The number of hidden layers.

TYPE: int DEFAULT: 12

num_attention_heads

The number of attention heads.

TYPE: int DEFAULT: 12

intermediate_size

The size of the intermediate layer in the transformer encoder.

TYPE: int DEFAULT: 3072

hidden_act

The activation function for the hidden layers.

TYPE: str DEFAULT: 'gelu'

hidden_dropout_prob

The dropout probability for the hidden layers.

TYPE: float DEFAULT: 0.1

attention_probs_dropout_prob

The dropout probability for the attention probabilities.

TYPE: float DEFAULT: 0.1

max_position_embeddings

The maximum position for positional embeddings.

TYPE: int DEFAULT: 512

type_vocab_size

The size of the type vocabulary.

TYPE: int DEFAULT: 2

initializer_range

The range for weight initialization.

TYPE: float DEFAULT: 0.02

layer_norm_eps

The epsilon value for layer normalization.

TYPE: float DEFAULT: 1e-12

pad_token_id

The id for padding tokens.

TYPE: int DEFAULT: 1

bos_token_id

The id for the beginning of sequence tokens.

TYPE: int DEFAULT: 0

eos_token_id

The id for the end of sequence tokens.

TYPE: int DEFAULT: 2

position_embedding_type

The type of position embedding to use.

TYPE: str DEFAULT: 'absolute'

use_cache

Whether to use cache for intermediate computations.

TYPE: bool DEFAULT: True

classifier_dropout

The dropout probability for the classifier. Default is None.

TYPE: float DEFAULT: None

RETURNS DESCRIPTION

None.
RAISES DESCRIPTION
ValueError

If vocab_size, hidden_size, num_hidden_layers, num_attention_heads, intermediate_size, max_position_embeddings, type_vocab_size are not positive integers.
ValueError

If hidden_dropout_prob, attention_probs_dropout_prob, initializer_range, layer_norm_eps, classifier_dropout are not in the range [0.0, 1.0].
ValueError

If position_embedding_type is not 'absolute' or 'relative'.
ValueError

If pad_token_id, bos_token_id, eos_token_id are not non-negative integers.
TypeError

If classifier_dropout is not a float or None.
Source code in mindnlp/transformers/models/xlm_roberta/configuration_xlm_roberta.py 
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
def __init__(
    self,
    vocab_size=30522,
    hidden_size=768,
    num_hidden_layers=12,
    num_attention_heads=12,
    intermediate_size=3072,
    hidden_act="gelu",
    hidden_dropout_prob=0.1,
    attention_probs_dropout_prob=0.1,
    max_position_embeddings=512,
    type_vocab_size=2,
    initializer_range=0.02,
    layer_norm_eps=1e-12,
    pad_token_id=1,
    bos_token_id=0,
    eos_token_id=2,
    position_embedding_type="absolute",
    use_cache=True,
    classifier_dropout=None,
    **kwargs,
):
    """
    The __init__ method initializes an instance of the XLMRobertaConfig class.

    Args:
        self: The instance of the class.
        vocab_size (int): The size of the vocabulary.
        hidden_size (int): The size of the hidden layers.
        num_hidden_layers (int): The number of hidden layers.
        num_attention_heads (int): The number of attention heads.
        intermediate_size (int): The size of the intermediate layer in the transformer encoder.
        hidden_act (str): The activation function for the hidden layers.
        hidden_dropout_prob (float): The dropout probability for the hidden layers.
        attention_probs_dropout_prob (float): The dropout probability for the attention probabilities.
        max_position_embeddings (int): The maximum position for positional embeddings.
        type_vocab_size (int): The size of the type vocabulary.
        initializer_range (float): The range for weight initialization.
        layer_norm_eps (float): The epsilon value for layer normalization.
        pad_token_id (int): The id for padding tokens.
        bos_token_id (int): The id for the beginning of sequence tokens.
        eos_token_id (int): The id for the end of sequence tokens.
        position_embedding_type (str): The type of position embedding to use.
        use_cache (bool): Whether to use cache for intermediate computations.
        classifier_dropout (float): The dropout probability for the classifier. Default is None.

    Returns:
        None.

    Raises:
        ValueError: If vocab_size, hidden_size, num_hidden_layers, num_attention_heads, intermediate_size,
            max_position_embeddings, type_vocab_size are not positive integers.
        ValueError: If hidden_dropout_prob, attention_probs_dropout_prob, initializer_range, layer_norm_eps,
            classifier_dropout are not in the range [0.0, 1.0].
        ValueError: If position_embedding_type is not 'absolute' or 'relative'.
        ValueError: If pad_token_id, bos_token_id, eos_token_id are not non-negative integers.
        TypeError: If classifier_dropout is not a float or None.
    """
    super().__init__(pad_token_id=pad_token_id, bos_token_id=bos_token_id, eos_token_id=eos_token_id, **kwargs)

    self.vocab_size = vocab_size
    self.hidden_size = hidden_size
    self.num_hidden_layers = num_hidden_layers
    self.num_attention_heads = num_attention_heads
    self.hidden_act = hidden_act
    self.intermediate_size = intermediate_size
    self.hidden_dropout_prob = hidden_dropout_prob
    self.attention_probs_dropout_prob = attention_probs_dropout_prob
    self.max_position_embeddings = max_position_embeddings
    self.type_vocab_size = type_vocab_size
    self.initializer_range = initializer_range
    self.layer_norm_eps = layer_norm_eps
    self.position_embedding_type = position_embedding_type
    self.use_cache = use_cache
    self.classifier_dropout = classifier_dropout

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta

MindSpore XLM-RoBERTa model.

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaAttention

Bases: Module

XLMRobertaAttention

Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
class XLMRobertaAttention(nn.Module):
    """XLMRobertaAttention"""
    def __init__(self, config, position_embedding_type=None):
        """
        Initializes an instance of XLMRobertaAttention.

        Args:
            self (object): The instance of the class itself.
            config (object): An object containing configuration settings.
            position_embedding_type (str, optional): The type of position embedding to use. Default is None.

        Returns:
            None.

        Raises:
            None.
        """
        super().__init__()
        self.self = XLMRobertaSelfAttention(config, position_embedding_type=position_embedding_type)
        self.output = XLMRobertaSelfOutput(config)
        self.pruned_heads = set()

    def prune_heads(self, heads):
        """prune heads"""
        if len(heads) == 0:
            return
        heads, index = find_pruneable_heads_and_indices(
            heads, self.self.num_attention_heads, self.self.attention_head_size, self.pruned_heads
        )

        # Prune linear layers
        self.self.query = prune_linear_layer(self.self.query, index)
        self.self.key = prune_linear_layer(self.self.key, index)
        self.self.value = prune_linear_layer(self.self.value, index)
        self.output.dense = prune_linear_layer(self.output.dense, index, dim=1)

        # Update hyper params and store pruned heads
        self.self.num_attention_heads = self.self.num_attention_heads - len(heads)
        self.self.all_head_size = self.self.attention_head_size * self.self.num_attention_heads
        self.pruned_heads = self.pruned_heads.union(heads)

    def forward(
        self,
        hidden_states: mindspore.Tensor,
        attention_mask: Optional[mindspore.Tensor] = None,
        head_mask: Optional[mindspore.Tensor] = None,
        encoder_hidden_states: Optional[mindspore.Tensor] = None,
        encoder_attention_mask: Optional[mindspore.Tensor] = None,
        past_key_value: Optional[Tuple[Tuple[mindspore.Tensor]]] = None,
        output_attentions: Optional[bool] = False,
    ) -> Tuple[mindspore.Tensor]:
        """
        This method 'forward' in the class 'XLMRobertaAttention' forwards the output of the attention mechanism
        based on the input parameters.

        Args:
            self: The instance of the class.
            hidden_states (mindspore.Tensor): The input hidden states. Shape (batch_size, sequence_length, hidden_size).
            attention_mask (Optional[mindspore.Tensor]): Mask to avoid performing attention on padding tokens.
                Shape (batch_size, sequence_length).
            head_mask (Optional[mindspore.Tensor]): Mask to zero out selected heads of the attention mechanism.
                Shape (num_heads,).
            encoder_hidden_states (Optional[mindspore.Tensor]): Hidden states of the encoder if applicable.
                Shape (batch_size, sequence_length, hidden_size).
            encoder_attention_mask (Optional[mindspore.Tensor]): Mask for encoder attention if applicable.
                Shape (batch_size, sequence_length).
            past_key_value (Optional[Tuple[Tuple[mindspore.Tensor]]]): Past key and value tensors for fast decoding.
            output_attentions (Optional[bool]): Flag to indicate whether to output attentions.

        Returns:
            Tuple[mindspore.Tensor]: A tuple containing the attention output tensor.
                Shape (batch_size, sequence_length, hidden_size).

        Raises:
            None
        """
        self_outputs = self.self(
            hidden_states,
            attention_mask,
            head_mask,
            encoder_hidden_states,
            encoder_attention_mask,
            past_key_value,
            output_attentions,
        )
        attention_output = self.output(self_outputs[0], hidden_states)
        outputs = (attention_output,) + self_outputs[1:]  # add attentions if we output them
        return outputs

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaAttention.__init__(config, position_embedding_type=None)

Initializes an instance of XLMRobertaAttention.

PARAMETER DESCRIPTION
self

The instance of the class itself.

TYPE: object

config

An object containing configuration settings.

TYPE: object

position_embedding_type

The type of position embedding to use. Default is None.

TYPE: str DEFAULT: None

RETURNS DESCRIPTION

None.
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
def __init__(self, config, position_embedding_type=None):
    """
    Initializes an instance of XLMRobertaAttention.

    Args:
        self (object): The instance of the class itself.
        config (object): An object containing configuration settings.
        position_embedding_type (str, optional): The type of position embedding to use. Default is None.

    Returns:
        None.

    Raises:
        None.
    """
    super().__init__()
    self.self = XLMRobertaSelfAttention(config, position_embedding_type=position_embedding_type)
    self.output = XLMRobertaSelfOutput(config)
    self.pruned_heads = set()

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaAttention.forward(hidden_states, attention_mask=None, head_mask=None, encoder_hidden_states=None, encoder_attention_mask=None, past_key_value=None, output_attentions=False)

This method 'forward' in the class 'XLMRobertaAttention' forwards the output of the attention mechanism based on the input parameters.

PARAMETER DESCRIPTION
self

The instance of the class.
hidden_states

The input hidden states. Shape (batch_size, sequence_length, hidden_size).

TYPE: Tensor

attention_mask

Mask to avoid performing attention on padding tokens. Shape (batch_size, sequence_length).

TYPE: Optional[Tensor] DEFAULT: None

head_mask

Mask to zero out selected heads of the attention mechanism. Shape (num_heads,).

TYPE: Optional[Tensor] DEFAULT: None

encoder_hidden_states

Hidden states of the encoder if applicable. Shape (batch_size, sequence_length, hidden_size).

TYPE: Optional[Tensor] DEFAULT: None

encoder_attention_mask

Mask for encoder attention if applicable. Shape (batch_size, sequence_length).

TYPE: Optional[Tensor] DEFAULT: None

past_key_value

Past key and value tensors for fast decoding.

TYPE: Optional[Tuple[Tuple[Tensor]]] DEFAULT: None

output_attentions

Flag to indicate whether to output attentions.

TYPE: Optional[bool] DEFAULT: False

RETURNS DESCRIPTION
Tuple[Tensor]

Tuple[mindspore.Tensor]: A tuple containing the attention output tensor. Shape (batch_size, sequence_length, hidden_size).
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
def forward(
    self,
    hidden_states: mindspore.Tensor,
    attention_mask: Optional[mindspore.Tensor] = None,
    head_mask: Optional[mindspore.Tensor] = None,
    encoder_hidden_states: Optional[mindspore.Tensor] = None,
    encoder_attention_mask: Optional[mindspore.Tensor] = None,
    past_key_value: Optional[Tuple[Tuple[mindspore.Tensor]]] = None,
    output_attentions: Optional[bool] = False,
) -> Tuple[mindspore.Tensor]:
    """
    This method 'forward' in the class 'XLMRobertaAttention' forwards the output of the attention mechanism
    based on the input parameters.

    Args:
        self: The instance of the class.
        hidden_states (mindspore.Tensor): The input hidden states. Shape (batch_size, sequence_length, hidden_size).
        attention_mask (Optional[mindspore.Tensor]): Mask to avoid performing attention on padding tokens.
            Shape (batch_size, sequence_length).
        head_mask (Optional[mindspore.Tensor]): Mask to zero out selected heads of the attention mechanism.
            Shape (num_heads,).
        encoder_hidden_states (Optional[mindspore.Tensor]): Hidden states of the encoder if applicable.
            Shape (batch_size, sequence_length, hidden_size).
        encoder_attention_mask (Optional[mindspore.Tensor]): Mask for encoder attention if applicable.
            Shape (batch_size, sequence_length).
        past_key_value (Optional[Tuple[Tuple[mindspore.Tensor]]]): Past key and value tensors for fast decoding.
        output_attentions (Optional[bool]): Flag to indicate whether to output attentions.

    Returns:
        Tuple[mindspore.Tensor]: A tuple containing the attention output tensor.
            Shape (batch_size, sequence_length, hidden_size).

    Raises:
        None
    """
    self_outputs = self.self(
        hidden_states,
        attention_mask,
        head_mask,
        encoder_hidden_states,
        encoder_attention_mask,
        past_key_value,
        output_attentions,
    )
    attention_output = self.output(self_outputs[0], hidden_states)
    outputs = (attention_output,) + self_outputs[1:]  # add attentions if we output them
    return outputs

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaAttention.prune_heads(heads)

prune heads

Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
def prune_heads(self, heads):
    """prune heads"""
    if len(heads) == 0:
        return
    heads, index = find_pruneable_heads_and_indices(
        heads, self.self.num_attention_heads, self.self.attention_head_size, self.pruned_heads
    )

    # Prune linear layers
    self.self.query = prune_linear_layer(self.self.query, index)
    self.self.key = prune_linear_layer(self.self.key, index)
    self.self.value = prune_linear_layer(self.self.value, index)
    self.output.dense = prune_linear_layer(self.output.dense, index, dim=1)

    # Update hyper params and store pruned heads
    self.self.num_attention_heads = self.self.num_attention_heads - len(heads)
    self.self.all_head_size = self.self.attention_head_size * self.self.num_attention_heads
    self.pruned_heads = self.pruned_heads.union(heads)

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaClassificationHead

Bases: Module

Head for sentence-level classification tasks.

Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
class XLMRobertaClassificationHead(nn.Module):
    """Head for sentence-level classification tasks."""
    def __init__(self, config):
        """
        Initializes an instance of the XLMRobertaClassificationHead class.

        Args:
            self: The current instance of the class.
            config: An instance of the configuration class containing the model's configuration parameters.

        Returns:
            None.

        Raises:
            None.
        """
        super().__init__()
        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
        classifier_dropout = (
            config.classifier_dropout if config.classifier_dropout is not None else config.hidden_dropout_prob
        )
        self.dropout = nn.Dropout(p=classifier_dropout)
        self.out_proj = nn.Linear(config.hidden_size, config.num_labels)

    def forward(self, features, **kwargs):
        """
        Constructs the XLMRobertaClassificationHead.

        This method forwards the classification head for the XLM-RoBERTa model. It takes in a set of features and
        applies several operations to generate the final output.

        Args:
            self (XLMRobertaClassificationHead): An instance of the XLMRobertaClassificationHead class.
            features (Tensor): The input features for the classification head. It should have the shape
                (batch_size, sequence_length, num_features).

        Returns:
            Tensor: The output tensor of the classification head. It has the shape
                (batch_size, sequence_length, output_size).

        Raises:
            None.
        """
        x = features[:, 0, :]  # take <s> token (equiv. to [CLS])
        x = self.dropout(x)
        x = self.dense(x)
        x = ops.tanh(x)
        x = self.dropout(x)
        x = self.out_proj(x)
        return x

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaClassificationHead.__init__(config)

Initializes an instance of the XLMRobertaClassificationHead class.

PARAMETER DESCRIPTION
self

The current instance of the class.
config

An instance of the configuration class containing the model's configuration parameters.
RETURNS DESCRIPTION

None.
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
def __init__(self, config):
    """
    Initializes an instance of the XLMRobertaClassificationHead class.

    Args:
        self: The current instance of the class.
        config: An instance of the configuration class containing the model's configuration parameters.

    Returns:
        None.

    Raises:
        None.
    """
    super().__init__()
    self.dense = nn.Linear(config.hidden_size, config.hidden_size)
    classifier_dropout = (
        config.classifier_dropout if config.classifier_dropout is not None else config.hidden_dropout_prob
    )
    self.dropout = nn.Dropout(p=classifier_dropout)
    self.out_proj = nn.Linear(config.hidden_size, config.num_labels)

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaClassificationHead.forward(features, **kwargs)

Constructs the XLMRobertaClassificationHead.

This method forwards the classification head for the XLM-RoBERTa model. It takes in a set of features and applies several operations to generate the final output.

PARAMETER DESCRIPTION
self

An instance of the XLMRobertaClassificationHead class.

TYPE: XLMRobertaClassificationHead

features

The input features for the classification head. It should have the shape (batch_size, sequence_length, num_features).

TYPE: Tensor

RETURNS DESCRIPTION
Tensor

The output tensor of the classification head. It has the shape (batch_size, sequence_length, output_size).
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
def forward(self, features, **kwargs):
    """
    Constructs the XLMRobertaClassificationHead.

    This method forwards the classification head for the XLM-RoBERTa model. It takes in a set of features and
    applies several operations to generate the final output.

    Args:
        self (XLMRobertaClassificationHead): An instance of the XLMRobertaClassificationHead class.
        features (Tensor): The input features for the classification head. It should have the shape
            (batch_size, sequence_length, num_features).

    Returns:
        Tensor: The output tensor of the classification head. It has the shape
            (batch_size, sequence_length, output_size).

    Raises:
        None.
    """
    x = features[:, 0, :]  # take <s> token (equiv. to [CLS])
    x = self.dropout(x)
    x = self.dense(x)
    x = ops.tanh(x)
    x = self.dropout(x)
    x = self.out_proj(x)
    return x

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaEmbeddings

Bases: Module

Same as BertEmbeddings with a tiny tweak for positional embeddings indexing.

Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
class XLMRobertaEmbeddings(nn.Module):
    """
    Same as BertEmbeddings with a tiny tweak for positional embeddings indexing.
    """
    # Copied from transformers.models.bert.modeling_bert.BertEmbeddings.__init__
    def __init__(self, config):
        """
        __init__

        Initializes a new instance of the XLMRobertaEmbeddings class.

        Args:
            self: The instance of the XLMRobertaEmbeddings class.
            config: An object containing configuration parameters for the XLMRoberta model.
                It includes the following attributes:

                - vocab_size (int): The size of the vocabulary.
                - hidden_size (int): The dimension of the hidden layers.
                - max_position_embeddings (int): The maximum number of positional embeddings.
                - type_vocab_size (int): The size of the token type vocabulary.
                - layer_norm_eps (float): The epsilon value for layer normalization.
                - hidden_dropout_prob (float): The dropout probability.
                - position_embedding_type (str, optional): The type of position embedding. Defaults to 'absolute'.
                - pad_token_id (int): The id of the padding token.

        Returns:
            None.

        Raises:
            None.
        """
        super().__init__()
        self.word_embeddings = nn.Embedding(config.vocab_size, config.hidden_size, padding_idx=config.pad_token_id)
        self.position_embeddings = nn.Embedding(config.max_position_embeddings, config.hidden_size)
        self.token_type_embeddings = nn.Embedding(config.type_vocab_size, config.hidden_size)

        # self.LayerNorm is not snake-cased to stick with TensorFlow model variable name and be able to load
        # any TensorFlow checkpoint file
        self.LayerNorm = nn.LayerNorm([config.hidden_size,], eps=config.layer_norm_eps)
        self.dropout = nn.Dropout(p=config.hidden_dropout_prob)
        # position_ids (1, len position emb) is contiguous in memory and exported when serialized
        self.position_embedding_type = getattr(config, "position_embedding_type", "absolute")
        self.position_ids = ops.arange(config.max_position_embeddings).broadcast_to((1, -1))
        self.token_type_ids = ops.zeros(self.position_ids.shape, dtype=mindspore.int64)

        # End copy
        self.padding_idx = config.pad_token_id
        self.position_embeddings = nn.Embedding(
            config.max_position_embeddings, config.hidden_size, padding_idx=self.padding_idx
        )

    def forward(
        self, input_ids=None, token_type_ids=None, position_ids=None, inputs_embeds=None, past_key_values_length=0
    ):
        """
        This method forwards the embeddings for the XLM-Roberta model.

        Args:
            self: (object) The instance of the class.
            input_ids: (Tensor, optional) The input tensor containing the token ids. Default is None.
            token_type_ids: (Tensor, optional) The input tensor containing the token type ids. Default is None.
            position_ids: (Tensor, optional) The input tensor containing the position ids. Default is None.
            inputs_embeds: (Tensor, optional) The input embeddings tensor. Default is None.
            past_key_values_length: (int) The length of the past key values. Default is 0.

        Returns:
            embeddings: (Tensor) The forwarded embeddings for the XLM-Roberta model.

        Raises:
            ValueError: If both input_ids and inputs_embeds are None, or if an unsupported position_embedding_type
                is provided.
            IndexError: If input_ids or inputs_embeds do not have the expected shape.
            AttributeError: If the 'token_type_ids' attribute is missing in the class.
        """
        if position_ids is None:
            if input_ids is not None:
                # Create the position ids from the input token ids. Any padded tokens remain padded.
                position_ids = create_position_ids_from_input_ids(input_ids, self.padding_idx, past_key_values_length)
            else:
                position_ids = self.create_position_ids_from_inputs_embeds(inputs_embeds)

        if input_ids is not None:
            input_shape = input_ids.shape
        else:
            input_shape = inputs_embeds.shape[:-1]

        seq_length = input_shape[1]

        # Setting the token_type_ids to the registered buffer in forwardor where it is all zeros, which usually occurs
        # when its auto-generated, registered buffer helps users when tracing the model without passing token_type_ids, solves
        # issue #5664
        if token_type_ids is None:
            if hasattr(self, "token_type_ids"):
                buffered_token_type_ids = self.token_type_ids[:, :seq_length]
                buffered_token_type_ids_expanded = buffered_token_type_ids.expand(input_shape[0], seq_length)
                token_type_ids = buffered_token_type_ids_expanded
            else:
                token_type_ids = ops.zeros(input_shape, dtype=mindspore.int64)

        if inputs_embeds is None:
            inputs_embeds = self.word_embeddings(input_ids)
        token_type_embeddings = self.token_type_embeddings(token_type_ids)

        embeddings = inputs_embeds + token_type_embeddings
        if self.position_embedding_type == "absolute":
            position_embeddings = self.position_embeddings(position_ids)
            embeddings += position_embeddings
        embeddings = self.LayerNorm(embeddings)
        embeddings = self.dropout(embeddings)
        return embeddings

    def create_position_ids_from_inputs_embeds(self, inputs_embeds):
        """
        We are provided embeddings directly. We cannot infer which are padded so just generate sequential position ids.

        Args:
            inputs_embeds: mindspore.Tensor

        Returns: mindspore.Tensor
        """
        input_shape = inputs_embeds.shape[:-1]
        sequence_length = input_shape[1]

        position_ids = ops.arange(
            self.padding_idx + 1, sequence_length + self.padding_idx + 1, dtype=mindspore.int64)
        return position_ids.unsqueeze(0).expand(input_shape)

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaEmbeddings.__init__(config)

init

Initializes a new instance of the XLMRobertaEmbeddings class.

PARAMETER DESCRIPTION
self

The instance of the XLMRobertaEmbeddings class.
config

An object containing configuration parameters for the XLMRoberta model. It includes the following attributes:

  • vocab_size (int): The size of the vocabulary.
  • hidden_size (int): The dimension of the hidden layers.
  • max_position_embeddings (int): The maximum number of positional embeddings.
  • type_vocab_size (int): The size of the token type vocabulary.
  • layer_norm_eps (float): The epsilon value for layer normalization.
  • hidden_dropout_prob (float): The dropout probability.
  • position_embedding_type (str, optional): The type of position embedding. Defaults to 'absolute'.
  • pad_token_id (int): The id of the padding token.
RETURNS DESCRIPTION

None.
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
def __init__(self, config):
    """
    __init__

    Initializes a new instance of the XLMRobertaEmbeddings class.

    Args:
        self: The instance of the XLMRobertaEmbeddings class.
        config: An object containing configuration parameters for the XLMRoberta model.
            It includes the following attributes:

            - vocab_size (int): The size of the vocabulary.
            - hidden_size (int): The dimension of the hidden layers.
            - max_position_embeddings (int): The maximum number of positional embeddings.
            - type_vocab_size (int): The size of the token type vocabulary.
            - layer_norm_eps (float): The epsilon value for layer normalization.
            - hidden_dropout_prob (float): The dropout probability.
            - position_embedding_type (str, optional): The type of position embedding. Defaults to 'absolute'.
            - pad_token_id (int): The id of the padding token.

    Returns:
        None.

    Raises:
        None.
    """
    super().__init__()
    self.word_embeddings = nn.Embedding(config.vocab_size, config.hidden_size, padding_idx=config.pad_token_id)
    self.position_embeddings = nn.Embedding(config.max_position_embeddings, config.hidden_size)
    self.token_type_embeddings = nn.Embedding(config.type_vocab_size, config.hidden_size)

    # self.LayerNorm is not snake-cased to stick with TensorFlow model variable name and be able to load
    # any TensorFlow checkpoint file
    self.LayerNorm = nn.LayerNorm([config.hidden_size,], eps=config.layer_norm_eps)
    self.dropout = nn.Dropout(p=config.hidden_dropout_prob)
    # position_ids (1, len position emb) is contiguous in memory and exported when serialized
    self.position_embedding_type = getattr(config, "position_embedding_type", "absolute")
    self.position_ids = ops.arange(config.max_position_embeddings).broadcast_to((1, -1))
    self.token_type_ids = ops.zeros(self.position_ids.shape, dtype=mindspore.int64)

    # End copy
    self.padding_idx = config.pad_token_id
    self.position_embeddings = nn.Embedding(
        config.max_position_embeddings, config.hidden_size, padding_idx=self.padding_idx
    )

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaEmbeddings.create_position_ids_from_inputs_embeds(inputs_embeds)

We are provided embeddings directly. We cannot infer which are padded so just generate sequential position ids.

PARAMETER DESCRIPTION
inputs_embeds

mindspore.Tensor
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
def create_position_ids_from_inputs_embeds(self, inputs_embeds):
    """
    We are provided embeddings directly. We cannot infer which are padded so just generate sequential position ids.

    Args:
        inputs_embeds: mindspore.Tensor

    Returns: mindspore.Tensor
    """
    input_shape = inputs_embeds.shape[:-1]
    sequence_length = input_shape[1]

    position_ids = ops.arange(
        self.padding_idx + 1, sequence_length + self.padding_idx + 1, dtype=mindspore.int64)
    return position_ids.unsqueeze(0).expand(input_shape)

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaEmbeddings.forward(input_ids=None, token_type_ids=None, position_ids=None, inputs_embeds=None, past_key_values_length=0)

This method forwards the embeddings for the XLM-Roberta model.

PARAMETER DESCRIPTION
self

(object) The instance of the class.
input_ids

(Tensor, optional) The input tensor containing the token ids. Default is None.

DEFAULT: None

token_type_ids

(Tensor, optional) The input tensor containing the token type ids. Default is None.

DEFAULT: None

position_ids

(Tensor, optional) The input tensor containing the position ids. Default is None.

DEFAULT: None

inputs_embeds

(Tensor, optional) The input embeddings tensor. Default is None.

DEFAULT: None

past_key_values_length

(int) The length of the past key values. Default is 0.

DEFAULT: 0

RETURNS DESCRIPTION
embeddings

(Tensor) The forwarded embeddings for the XLM-Roberta model.
RAISES DESCRIPTION
ValueError

If both input_ids and inputs_embeds are None, or if an unsupported position_embedding_type is provided.
IndexError

If input_ids or inputs_embeds do not have the expected shape.
AttributeError

If the 'token_type_ids' attribute is missing in the class.
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
def forward(
    self, input_ids=None, token_type_ids=None, position_ids=None, inputs_embeds=None, past_key_values_length=0
):
    """
    This method forwards the embeddings for the XLM-Roberta model.

    Args:
        self: (object) The instance of the class.
        input_ids: (Tensor, optional) The input tensor containing the token ids. Default is None.
        token_type_ids: (Tensor, optional) The input tensor containing the token type ids. Default is None.
        position_ids: (Tensor, optional) The input tensor containing the position ids. Default is None.
        inputs_embeds: (Tensor, optional) The input embeddings tensor. Default is None.
        past_key_values_length: (int) The length of the past key values. Default is 0.

    Returns:
        embeddings: (Tensor) The forwarded embeddings for the XLM-Roberta model.

    Raises:
        ValueError: If both input_ids and inputs_embeds are None, or if an unsupported position_embedding_type
            is provided.
        IndexError: If input_ids or inputs_embeds do not have the expected shape.
        AttributeError: If the 'token_type_ids' attribute is missing in the class.
    """
    if position_ids is None:
        if input_ids is not None:
            # Create the position ids from the input token ids. Any padded tokens remain padded.
            position_ids = create_position_ids_from_input_ids(input_ids, self.padding_idx, past_key_values_length)
        else:
            position_ids = self.create_position_ids_from_inputs_embeds(inputs_embeds)

    if input_ids is not None:
        input_shape = input_ids.shape
    else:
        input_shape = inputs_embeds.shape[:-1]

    seq_length = input_shape[1]

    # Setting the token_type_ids to the registered buffer in forwardor where it is all zeros, which usually occurs
    # when its auto-generated, registered buffer helps users when tracing the model without passing token_type_ids, solves
    # issue #5664
    if token_type_ids is None:
        if hasattr(self, "token_type_ids"):
            buffered_token_type_ids = self.token_type_ids[:, :seq_length]
            buffered_token_type_ids_expanded = buffered_token_type_ids.expand(input_shape[0], seq_length)
            token_type_ids = buffered_token_type_ids_expanded
        else:
            token_type_ids = ops.zeros(input_shape, dtype=mindspore.int64)

    if inputs_embeds is None:
        inputs_embeds = self.word_embeddings(input_ids)
    token_type_embeddings = self.token_type_embeddings(token_type_ids)

    embeddings = inputs_embeds + token_type_embeddings
    if self.position_embedding_type == "absolute":
        position_embeddings = self.position_embeddings(position_ids)
        embeddings += position_embeddings
    embeddings = self.LayerNorm(embeddings)
    embeddings = self.dropout(embeddings)
    return embeddings

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaEncoder

Bases: Module

XLMRobertaEncoder

Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
class XLMRobertaEncoder(nn.Module):
    """XLMRobertaEncoder"""
    def __init__(self, config):
        """
        Initializes a new XLMRobertaEncoder object.

        Args:
            self (XLMRobertaEncoder): The XLMRobertaEncoder instance.
            config (object): The configuration object containing parameters for the encoder.
                It is expected to have attributes such as 'num_hidden_layers' to specify the number of hidden layers.

        Returns:
            None.

        Raises:
            None.
        """
        super().__init__()
        self.config = config
        self.layer = nn.ModuleList([XLMRobertaLayer(config) for _ in range(config.num_hidden_layers)])
        self.gradient_checkpointing = False

    def forward(
        self,
        hidden_states: mindspore.Tensor,
        attention_mask: Optional[mindspore.Tensor] = None,
        head_mask: Optional[mindspore.Tensor] = None,
        encoder_hidden_states: Optional[mindspore.Tensor] = None,
        encoder_attention_mask: Optional[mindspore.Tensor] = None,
        past_key_values: Optional[Tuple[Tuple[mindspore.Tensor]]] = None,
        use_cache: Optional[bool] = None,
        output_attentions: Optional[bool] = False,
        output_hidden_states: Optional[bool] = False,
        return_dict: Optional[bool] = True,
    ) -> Union[Tuple[mindspore.Tensor], BaseModelOutputWithPastAndCrossAttentions]:
        """
        This method forwards the XLMRobertaEncoder.

        Args:
            self: The instance of the XLMRobertaEncoder class.
            hidden_states (mindspore.Tensor): The input hidden states.
            attention_mask (Optional[mindspore.Tensor]): An optional tensor to mask the attention scores.
                Default is None.
            head_mask (Optional[mindspore.Tensor]): An optional tensor to mask the attention scores of each head.
                Default is None.
            encoder_hidden_states (Optional[mindspore.Tensor]): An optional tensor containing the hidden states of
                the encoder. Default is None.
            encoder_attention_mask (Optional[mindspore.Tensor]): An optional tensor to mask the encoder attention scores.
                Default is None.
            past_key_values (Optional[Tuple[Tuple[mindspore.Tensor]]]): An optional tuple of past key values.
                Default is None.
            use_cache (Optional[bool]): An optional boolean to use caching. Default is None.
            output_attentions (Optional[bool]): An optional boolean to output attention. Default is False.
            output_hidden_states (Optional[bool]): An optional boolean to output hidden states. Default is False.
            return_dict (Optional[bool]): An optional boolean to return a dictionary. Default is True.

        Returns:
            Union[Tuple[mindspore.Tensor], BaseModelOutputWithPastAndCrossAttentions]:
                Returns either a tuple of tensors or an instance of BaseModelOutputWithPastAndCrossAttentions based on
                the return_dict value.

        Raises:
            Warning: If use_cache is set to True while using gradient checkpointing, a warning is raised notifying that
                it is incompatible, and use_cache is set to False.
        """
        all_hidden_states = () if output_hidden_states else None
        all_self_attentions = () if output_attentions else None
        all_cross_attentions = () if output_attentions and self.config.add_cross_attention else None

        if self.gradient_checkpointing and self.training:
            if use_cache:
                logger.warning_once(
                    "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..."
                )
                use_cache = False

        next_decoder_cache = () if use_cache else None
        for i, layer_module in enumerate(self.layer):
            if output_hidden_states:
                all_hidden_states = all_hidden_states + (hidden_states,)

            layer_head_mask = head_mask[i] if head_mask is not None else None
            past_key_value = past_key_values[i] if past_key_values is not None else None

            layer_outputs = layer_module(
                hidden_states,
                attention_mask,
                layer_head_mask,
                encoder_hidden_states,
                encoder_attention_mask,
                past_key_value,
                output_attentions,
            )

            hidden_states = layer_outputs[0]
            if use_cache:
                next_decoder_cache += (layer_outputs[-1],)
            if output_attentions:
                all_self_attentions = all_self_attentions + (layer_outputs[1],)
                if self.config.add_cross_attention:
                    all_cross_attentions = all_cross_attentions + (layer_outputs[2],)

        if output_hidden_states:
            all_hidden_states = all_hidden_states + (hidden_states,)

        if not return_dict:
            return tuple(
                v
                for v in [
                    hidden_states,
                    next_decoder_cache,
                    all_hidden_states,
                    all_self_attentions,
                    all_cross_attentions,
                ]
                if v is not None
            )
        return BaseModelOutputWithPastAndCrossAttentions(
            last_hidden_state=hidden_states,
            past_key_values=next_decoder_cache,
            hidden_states=all_hidden_states,
            attentions=all_self_attentions,
            cross_attentions=all_cross_attentions,
        )

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaEncoder.__init__(config)

Initializes a new XLMRobertaEncoder object.

PARAMETER DESCRIPTION
self

The XLMRobertaEncoder instance.

TYPE: XLMRobertaEncoder

config

The configuration object containing parameters for the encoder. It is expected to have attributes such as 'num_hidden_layers' to specify the number of hidden layers.

TYPE: object

RETURNS DESCRIPTION

None.
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
def __init__(self, config):
    """
    Initializes a new XLMRobertaEncoder object.

    Args:
        self (XLMRobertaEncoder): The XLMRobertaEncoder instance.
        config (object): The configuration object containing parameters for the encoder.
            It is expected to have attributes such as 'num_hidden_layers' to specify the number of hidden layers.

    Returns:
        None.

    Raises:
        None.
    """
    super().__init__()
    self.config = config
    self.layer = nn.ModuleList([XLMRobertaLayer(config) for _ in range(config.num_hidden_layers)])
    self.gradient_checkpointing = False

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaEncoder.forward(hidden_states, attention_mask=None, head_mask=None, encoder_hidden_states=None, encoder_attention_mask=None, past_key_values=None, use_cache=None, output_attentions=False, output_hidden_states=False, return_dict=True)

This method forwards the XLMRobertaEncoder.

PARAMETER DESCRIPTION
self

The instance of the XLMRobertaEncoder class.
hidden_states

The input hidden states.

TYPE: Tensor

attention_mask

An optional tensor to mask the attention scores. Default is None.

TYPE: Optional[Tensor] DEFAULT: None

head_mask

An optional tensor to mask the attention scores of each head. Default is None.

TYPE: Optional[Tensor] DEFAULT: None

encoder_hidden_states

An optional tensor containing the hidden states of the encoder. Default is None.

TYPE: Optional[Tensor] DEFAULT: None

encoder_attention_mask

An optional tensor to mask the encoder attention scores. Default is None.

TYPE: Optional[Tensor] DEFAULT: None

past_key_values

An optional tuple of past key values. Default is None.

TYPE: Optional[Tuple[Tuple[Tensor]]] DEFAULT: None

use_cache

An optional boolean to use caching. Default is None.

TYPE: Optional[bool] DEFAULT: None

output_attentions

An optional boolean to output attention. Default is False.

TYPE: Optional[bool] DEFAULT: False

output_hidden_states

An optional boolean to output hidden states. Default is False.

TYPE: Optional[bool] DEFAULT: False

return_dict

An optional boolean to return a dictionary. Default is True.

TYPE: Optional[bool] DEFAULT: True

RETURNS DESCRIPTION
Union[Tuple[Tensor], BaseModelOutputWithPastAndCrossAttentions]

Union[Tuple[mindspore.Tensor], BaseModelOutputWithPastAndCrossAttentions]: Returns either a tuple of tensors or an instance of BaseModelOutputWithPastAndCrossAttentions based on the return_dict value.
RAISES DESCRIPTION
Warning

If use_cache is set to True while using gradient checkpointing, a warning is raised notifying that it is incompatible, and use_cache is set to False.
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
def forward(
    self,
    hidden_states: mindspore.Tensor,
    attention_mask: Optional[mindspore.Tensor] = None,
    head_mask: Optional[mindspore.Tensor] = None,
    encoder_hidden_states: Optional[mindspore.Tensor] = None,
    encoder_attention_mask: Optional[mindspore.Tensor] = None,
    past_key_values: Optional[Tuple[Tuple[mindspore.Tensor]]] = None,
    use_cache: Optional[bool] = None,
    output_attentions: Optional[bool] = False,
    output_hidden_states: Optional[bool] = False,
    return_dict: Optional[bool] = True,
) -> Union[Tuple[mindspore.Tensor], BaseModelOutputWithPastAndCrossAttentions]:
    """
    This method forwards the XLMRobertaEncoder.

    Args:
        self: The instance of the XLMRobertaEncoder class.
        hidden_states (mindspore.Tensor): The input hidden states.
        attention_mask (Optional[mindspore.Tensor]): An optional tensor to mask the attention scores.
            Default is None.
        head_mask (Optional[mindspore.Tensor]): An optional tensor to mask the attention scores of each head.
            Default is None.
        encoder_hidden_states (Optional[mindspore.Tensor]): An optional tensor containing the hidden states of
            the encoder. Default is None.
        encoder_attention_mask (Optional[mindspore.Tensor]): An optional tensor to mask the encoder attention scores.
            Default is None.
        past_key_values (Optional[Tuple[Tuple[mindspore.Tensor]]]): An optional tuple of past key values.
            Default is None.
        use_cache (Optional[bool]): An optional boolean to use caching. Default is None.
        output_attentions (Optional[bool]): An optional boolean to output attention. Default is False.
        output_hidden_states (Optional[bool]): An optional boolean to output hidden states. Default is False.
        return_dict (Optional[bool]): An optional boolean to return a dictionary. Default is True.

    Returns:
        Union[Tuple[mindspore.Tensor], BaseModelOutputWithPastAndCrossAttentions]:
            Returns either a tuple of tensors or an instance of BaseModelOutputWithPastAndCrossAttentions based on
            the return_dict value.

    Raises:
        Warning: If use_cache is set to True while using gradient checkpointing, a warning is raised notifying that
            it is incompatible, and use_cache is set to False.
    """
    all_hidden_states = () if output_hidden_states else None
    all_self_attentions = () if output_attentions else None
    all_cross_attentions = () if output_attentions and self.config.add_cross_attention else None

    if self.gradient_checkpointing and self.training:
        if use_cache:
            logger.warning_once(
                "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..."
            )
            use_cache = False

    next_decoder_cache = () if use_cache else None
    for i, layer_module in enumerate(self.layer):
        if output_hidden_states:
            all_hidden_states = all_hidden_states + (hidden_states,)

        layer_head_mask = head_mask[i] if head_mask is not None else None
        past_key_value = past_key_values[i] if past_key_values is not None else None

        layer_outputs = layer_module(
            hidden_states,
            attention_mask,
            layer_head_mask,
            encoder_hidden_states,
            encoder_attention_mask,
            past_key_value,
            output_attentions,
        )

        hidden_states = layer_outputs[0]
        if use_cache:
            next_decoder_cache += (layer_outputs[-1],)
        if output_attentions:
            all_self_attentions = all_self_attentions + (layer_outputs[1],)
            if self.config.add_cross_attention:
                all_cross_attentions = all_cross_attentions + (layer_outputs[2],)

    if output_hidden_states:
        all_hidden_states = all_hidden_states + (hidden_states,)

    if not return_dict:
        return tuple(
            v
            for v in [
                hidden_states,
                next_decoder_cache,
                all_hidden_states,
                all_self_attentions,
                all_cross_attentions,
            ]
            if v is not None
        )
    return BaseModelOutputWithPastAndCrossAttentions(
        last_hidden_state=hidden_states,
        past_key_values=next_decoder_cache,
        hidden_states=all_hidden_states,
        attentions=all_self_attentions,
        cross_attentions=all_cross_attentions,
    )

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaForCausalLM

Bases: XLMRobertaPreTrainedModel

XLMRobertaForCausalLM

Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
class XLMRobertaForCausalLM(XLMRobertaPreTrainedModel):
    """XLMRobertaForCausalLM"""
    _tied_weights_keys = ["lm_head.decoder.weight", "lm_head.decoder.bias"]

    def __init__(self, config):
        """
        Initializes an instance of the XLMRobertaForCausalLM class.

        Args:
            self: The instance of the class.
            config: An object representing the configuration for the XLMRobertaForCausalLM model.

        Returns:
            None.

        Raises:
            None.
        """
        super().__init__(config)

        if not config.is_decoder:
            logger.warning("If you want to use `XLMRobertaLMHeadModel` as a standalone, add `is_decoder=True.`")

        self.roberta = XLMRobertaModel(config, add_pooling_layer=False)
        self.lm_head = XLMRobertaLMHead(config)

        # Initialize weights and apply final processing
        self.post_init()

    def get_output_embeddings(self):
        """
        Method to retrieve the output embeddings from XLMRobertaForCausalLM model.

        Args:
            self (XLMRobertaForCausalLM): The instance of the XLMRobertaForCausalLM class.
                It is used to access the decoder of the model to get the output embeddings.

        Returns:
            decoder: This method does not return any value but directly provides access to the output embeddings
                through the decoder.

        Raises:
            None.
        """
        return self.lm_head.decoder

    def set_output_embeddings(self, new_embeddings):
        """
        Sets the output embeddings for the XLMRobertaForCausalLM model.

        Args:
            self (XLMRobertaForCausalLM): The instance of the XLMRobertaForCausalLM class.
            new_embeddings (torch.nn.Module): The new embeddings to be set as the output embeddings for the model.

        Returns:
            None.

        Raises:
            None.

        Note:
            The output embeddings are used in the decoder layer of the XLMRobertaForCausalLM model.
            By setting new embeddings, users can customize the output layer of the model according to their specific
            requirements.

        Example:
            ```python
            >>> model = XLMRobertaForCausalLM.from_pretrained('xlm-roberta-base')
            >>> new_embeddings = torch.nn.Embedding(10, 768)
            >>> model.set_output_embeddings(new_embeddings)
            ```
        """
        self.lm_head.decoder = new_embeddings

    def forward(
        self,
        input_ids: Optional[mindspore.Tensor] = None,
        attention_mask: Optional[mindspore.Tensor] = None,
        token_type_ids: Optional[mindspore.Tensor] = None,
        position_ids: Optional[mindspore.Tensor] = None,
        head_mask: Optional[mindspore.Tensor] = None,
        inputs_embeds: Optional[mindspore.Tensor] = None,
        encoder_hidden_states: Optional[mindspore.Tensor] = None,
        encoder_attention_mask: Optional[mindspore.Tensor] = None,
        labels: Optional[mindspore.Tensor] = None,
        past_key_values: Tuple[Tuple[mindspore.Tensor]] = None,
        use_cache: Optional[bool] = None,
        output_attentions: Optional[bool] = None,
        output_hidden_states: Optional[bool] = None,
        return_dict: Optional[bool] = None,
    ) -> Union[Tuple[mindspore.Tensor], CausalLMOutputWithCrossAttentions]:
        r"""
        Args:
            encoder_hidden_states  (`mindspore.Tensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
                Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention if
                the model is configured as a decoder.
            encoder_attention_mask (`mindspore.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
                Mask to avoid performing attention on the padding token indices of the encoder input.
                This mask is used in the cross-attention if the model is configured as a decoder.
                Mask values selected in `[0, 1]`:

                - 1 for tokens that are **not masked**,
                - 0 for tokens that are **masked**.
            labels (`mindspore.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
                Labels for computing the left-to-right language modeling loss (next word prediction). Indices should be in
                `[-100, 0, ..., config.vocab_size]` (see `input_ids` docstring) Tokens with indices set to `-100` are
                ignored (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`
            past_key_values (`tuple(tuple(mindspore.Tensor))` of length `config.n_layers` with each tuple having 4
                tensors of shape `(batch_size, num_heads, sequence_length - 1, embed_size_per_head)`):
                Contains precomputed key and value hidden states of the attention blocks. Can be used to speed up decoding.
                If `past_key_values` are used, the user can optionally input only the last `decoder_input_ids` (those that
                don't have their past key value states given to this model) of shape `(batch_size, 1)` instead of all
                `decoder_input_ids` of shape `(batch_size, sequence_length)`.
            use_cache (`bool`, *optional*):
                If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see
                `past_key_values`).

        Returns:
            Union[Tuple[mindspore.Tensor], CausalLMOutputWithCrossAttentions]

        Example:
            ```python
            >>> from transformers import AutoTokenizer, XLMRobertaForCausalLM, AutoConfig
            ...
            >>> tokenizer = AutoTokenizer.from_pretrained("roberta-base")
            >>> config = AutoConfig.from_pretrained("roberta-base")
            >>> config.is_decoder = True
            >>> model = XLMRobertaForCausalLM.from_pretrained("roberta-base", config=config)
            ...
            >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
            >>> outputs = model(**inputs)
            ...
            >>> prediction_logits = outputs.logits
            ```
        """
        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
        if labels is not None:
            use_cache = False

        outputs = self.roberta(
            input_ids,
            attention_mask=attention_mask,
            token_type_ids=token_type_ids,
            position_ids=position_ids,
            head_mask=head_mask,
            inputs_embeds=inputs_embeds,
            encoder_hidden_states=encoder_hidden_states,
            encoder_attention_mask=encoder_attention_mask,
            past_key_values=past_key_values,
            use_cache=use_cache,
            output_attentions=output_attentions,
            output_hidden_states=output_hidden_states,
            return_dict=return_dict,
        )

        sequence_output = outputs[0]
        prediction_scores = self.lm_head(sequence_output)

        lm_loss = None
        if labels is not None:
            # we are doing next-token prediction; shift prediction scores and input ids by one
            shifted_prediction_scores = prediction_scores[:, :-1, :]
            labels = labels[:, 1:]
            lm_loss = ops.cross_entropy(shifted_prediction_scores.view(-1, self.config.vocab_size), labels.view(-1))

        if not return_dict:
            output = (prediction_scores,) + outputs[2:]
            return ((lm_loss,) + output) if lm_loss is not None else output

        return CausalLMOutputWithCrossAttentions(
            loss=lm_loss,
            logits=prediction_scores,
            past_key_values=outputs.past_key_values,
            hidden_states=outputs.hidden_states,
            attentions=outputs.attentions,
            cross_attentions=outputs.cross_attentions,
        )

    def prepare_inputs_for_generation(self, input_ids, past_key_values=None, attention_mask=None, **model_kwargs):
        """
        Prepare inputs for generation.

        Args:
            self (XLMRobertaForCausalLM): The instance of the XLMRobertaForCausalLM class.
            input_ids (torch.Tensor): The input tensor containing token ids. Shape should be
                (batch_size, sequence_length).
            past_key_values (Optional[torch.Tensor]): A tensor containing past key values. Default is None.
            attention_mask (Optional[torch.Tensor]): A tensor containing attention mask. If None is provided,
                it will be initialized with ones. Default is None.

        Returns:
            None.

        Raises:
            None.
        """
        input_shape = input_ids.shape
        # if model is used as a decoder in encoder-decoder model, the decoder attention mask is created on the fly
        if attention_mask is None:
            attention_mask = input_ids.new_ones(input_shape)

        # cut decoder_input_ids if past is used
        if past_key_values is not None:
            input_ids = input_ids[:, -1:]

        return {"input_ids": input_ids, "attention_mask": attention_mask, "past_key_values": past_key_values}

    def _reorder_cache(self, past_key_values, beam_idx):
        """
        Reorders the cache of past key values based on the provided beam index.

        Args:
            self (XLMRobertaForCausalLM): The instance of XLMRobertaForCausalLM.
            past_key_values (tuple): A tuple of past key values for each layer.
            beam_idx (torch.Tensor): A tensor containing the beam indices.

        Returns:
            None.

        Raises:
            IndexError: If the beam index is out of range for the past_key_values.
            TypeError: If the input types are incorrect or incompatible.
        """
        reordered_past = ()
        for layer_past in past_key_values:
            reordered_past += (
                tuple(past_state.index_select(0, beam_idx) for past_state in layer_past),
            )
        return reordered_past

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaForCausalLM.__init__(config)

Initializes an instance of the XLMRobertaForCausalLM class.

PARAMETER DESCRIPTION
self

The instance of the class.
config

An object representing the configuration for the XLMRobertaForCausalLM model.
RETURNS DESCRIPTION

None.
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
def __init__(self, config):
    """
    Initializes an instance of the XLMRobertaForCausalLM class.

    Args:
        self: The instance of the class.
        config: An object representing the configuration for the XLMRobertaForCausalLM model.

    Returns:
        None.

    Raises:
        None.
    """
    super().__init__(config)

    if not config.is_decoder:
        logger.warning("If you want to use `XLMRobertaLMHeadModel` as a standalone, add `is_decoder=True.`")

    self.roberta = XLMRobertaModel(config, add_pooling_layer=False)
    self.lm_head = XLMRobertaLMHead(config)

    # Initialize weights and apply final processing
    self.post_init()

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaForCausalLM.forward(input_ids=None, attention_mask=None, token_type_ids=None, position_ids=None, head_mask=None, inputs_embeds=None, encoder_hidden_states=None, encoder_attention_mask=None, labels=None, past_key_values=None, use_cache=None, output_attentions=None, output_hidden_states=None, return_dict=None)

PARAMETER DESCRIPTION
encoder_hidden_states

Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention if the model is configured as a decoder.

TYPE: (`mindspore.Tensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional* DEFAULT: None

encoder_attention_mask

Mask to avoid performing attention on the padding token indices of the encoder input. This mask is used in the cross-attention if the model is configured as a decoder. Mask values selected in [0, 1]:

  • 1 for tokens that are not masked,
  • 0 for tokens that are masked.

TYPE: `mindspore.Tensor` of shape `(batch_size, sequence_length)`, *optional* DEFAULT: None

labels

Labels for computing the left-to-right language modeling loss (next word prediction). Indices should be in [-100, 0, ..., config.vocab_size] (see input_ids docstring) Tokens with indices set to -100 are ignored (masked), the loss is only computed for the tokens with labels in [0, ..., config.vocab_size]

TYPE: `mindspore.Tensor` of shape `(batch_size, sequence_length)`, *optional* DEFAULT: None

use_cache

If set to True, past_key_values key value states are returned and can be used to speed up decoding (see past_key_values).

TYPE: `bool`, *optional* DEFAULT: None

RETURNS DESCRIPTION
Union[Tuple[Tensor], CausalLMOutputWithCrossAttentions]

Union[Tuple[mindspore.Tensor], CausalLMOutputWithCrossAttentions]
Example 
>>> from transformers import AutoTokenizer, XLMRobertaForCausalLM, AutoConfig
...
>>> tokenizer = AutoTokenizer.from_pretrained("roberta-base")
>>> config = AutoConfig.from_pretrained("roberta-base")
>>> config.is_decoder = True
>>> model = XLMRobertaForCausalLM.from_pretrained("roberta-base", config=config)
...
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)
...
>>> prediction_logits = outputs.logits
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
def forward(
    self,
    input_ids: Optional[mindspore.Tensor] = None,
    attention_mask: Optional[mindspore.Tensor] = None,
    token_type_ids: Optional[mindspore.Tensor] = None,
    position_ids: Optional[mindspore.Tensor] = None,
    head_mask: Optional[mindspore.Tensor] = None,
    inputs_embeds: Optional[mindspore.Tensor] = None,
    encoder_hidden_states: Optional[mindspore.Tensor] = None,
    encoder_attention_mask: Optional[mindspore.Tensor] = None,
    labels: Optional[mindspore.Tensor] = None,
    past_key_values: Tuple[Tuple[mindspore.Tensor]] = None,
    use_cache: Optional[bool] = None,
    output_attentions: Optional[bool] = None,
    output_hidden_states: Optional[bool] = None,
    return_dict: Optional[bool] = None,
) -> Union[Tuple[mindspore.Tensor], CausalLMOutputWithCrossAttentions]:
    r"""
    Args:
        encoder_hidden_states  (`mindspore.Tensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
            Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention if
            the model is configured as a decoder.
        encoder_attention_mask (`mindspore.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
            Mask to avoid performing attention on the padding token indices of the encoder input.
            This mask is used in the cross-attention if the model is configured as a decoder.
            Mask values selected in `[0, 1]`:

            - 1 for tokens that are **not masked**,
            - 0 for tokens that are **masked**.
        labels (`mindspore.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
            Labels for computing the left-to-right language modeling loss (next word prediction). Indices should be in
            `[-100, 0, ..., config.vocab_size]` (see `input_ids` docstring) Tokens with indices set to `-100` are
            ignored (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`
        past_key_values (`tuple(tuple(mindspore.Tensor))` of length `config.n_layers` with each tuple having 4
            tensors of shape `(batch_size, num_heads, sequence_length - 1, embed_size_per_head)`):
            Contains precomputed key and value hidden states of the attention blocks. Can be used to speed up decoding.
            If `past_key_values` are used, the user can optionally input only the last `decoder_input_ids` (those that
            don't have their past key value states given to this model) of shape `(batch_size, 1)` instead of all
            `decoder_input_ids` of shape `(batch_size, sequence_length)`.
        use_cache (`bool`, *optional*):
            If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see
            `past_key_values`).

    Returns:
        Union[Tuple[mindspore.Tensor], CausalLMOutputWithCrossAttentions]

    Example:
        ```python
        >>> from transformers import AutoTokenizer, XLMRobertaForCausalLM, AutoConfig
        ...
        >>> tokenizer = AutoTokenizer.from_pretrained("roberta-base")
        >>> config = AutoConfig.from_pretrained("roberta-base")
        >>> config.is_decoder = True
        >>> model = XLMRobertaForCausalLM.from_pretrained("roberta-base", config=config)
        ...
        >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
        >>> outputs = model(**inputs)
        ...
        >>> prediction_logits = outputs.logits
        ```
    """
    return_dict = return_dict if return_dict is not None else self.config.use_return_dict
    if labels is not None:
        use_cache = False

    outputs = self.roberta(
        input_ids,
        attention_mask=attention_mask,
        token_type_ids=token_type_ids,
        position_ids=position_ids,
        head_mask=head_mask,
        inputs_embeds=inputs_embeds,
        encoder_hidden_states=encoder_hidden_states,
        encoder_attention_mask=encoder_attention_mask,
        past_key_values=past_key_values,
        use_cache=use_cache,
        output_attentions=output_attentions,
        output_hidden_states=output_hidden_states,
        return_dict=return_dict,
    )

    sequence_output = outputs[0]
    prediction_scores = self.lm_head(sequence_output)

    lm_loss = None
    if labels is not None:
        # we are doing next-token prediction; shift prediction scores and input ids by one
        shifted_prediction_scores = prediction_scores[:, :-1, :]
        labels = labels[:, 1:]
        lm_loss = ops.cross_entropy(shifted_prediction_scores.view(-1, self.config.vocab_size), labels.view(-1))

    if not return_dict:
        output = (prediction_scores,) + outputs[2:]
        return ((lm_loss,) + output) if lm_loss is not None else output

    return CausalLMOutputWithCrossAttentions(
        loss=lm_loss,
        logits=prediction_scores,
        past_key_values=outputs.past_key_values,
        hidden_states=outputs.hidden_states,
        attentions=outputs.attentions,
        cross_attentions=outputs.cross_attentions,
    )

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaForCausalLM.get_output_embeddings()

Method to retrieve the output embeddings from XLMRobertaForCausalLM model.

PARAMETER DESCRIPTION
self

The instance of the XLMRobertaForCausalLM class. It is used to access the decoder of the model to get the output embeddings.

TYPE: XLMRobertaForCausalLM

RETURNS DESCRIPTION
decoder

This method does not return any value but directly provides access to the output embeddings through the decoder.
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
def get_output_embeddings(self):
    """
    Method to retrieve the output embeddings from XLMRobertaForCausalLM model.

    Args:
        self (XLMRobertaForCausalLM): The instance of the XLMRobertaForCausalLM class.
            It is used to access the decoder of the model to get the output embeddings.

    Returns:
        decoder: This method does not return any value but directly provides access to the output embeddings
            through the decoder.

    Raises:
        None.
    """
    return self.lm_head.decoder

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaForCausalLM.prepare_inputs_for_generation(input_ids, past_key_values=None, attention_mask=None, **model_kwargs)

Prepare inputs for generation.

PARAMETER DESCRIPTION
self

The instance of the XLMRobertaForCausalLM class.

TYPE: XLMRobertaForCausalLM

input_ids

The input tensor containing token ids. Shape should be (batch_size, sequence_length).

TYPE: Tensor

past_key_values

A tensor containing past key values. Default is None.

TYPE: Optional[Tensor] DEFAULT: None

attention_mask

A tensor containing attention mask. If None is provided, it will be initialized with ones. Default is None.

TYPE: Optional[Tensor] DEFAULT: None

RETURNS DESCRIPTION

None.
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
def prepare_inputs_for_generation(self, input_ids, past_key_values=None, attention_mask=None, **model_kwargs):
    """
    Prepare inputs for generation.

    Args:
        self (XLMRobertaForCausalLM): The instance of the XLMRobertaForCausalLM class.
        input_ids (torch.Tensor): The input tensor containing token ids. Shape should be
            (batch_size, sequence_length).
        past_key_values (Optional[torch.Tensor]): A tensor containing past key values. Default is None.
        attention_mask (Optional[torch.Tensor]): A tensor containing attention mask. If None is provided,
            it will be initialized with ones. Default is None.

    Returns:
        None.

    Raises:
        None.
    """
    input_shape = input_ids.shape
    # if model is used as a decoder in encoder-decoder model, the decoder attention mask is created on the fly
    if attention_mask is None:
        attention_mask = input_ids.new_ones(input_shape)

    # cut decoder_input_ids if past is used
    if past_key_values is not None:
        input_ids = input_ids[:, -1:]

    return {"input_ids": input_ids, "attention_mask": attention_mask, "past_key_values": past_key_values}

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaForCausalLM.set_output_embeddings(new_embeddings)

Sets the output embeddings for the XLMRobertaForCausalLM model.

PARAMETER DESCRIPTION
self

The instance of the XLMRobertaForCausalLM class.

TYPE: XLMRobertaForCausalLM

new_embeddings

The new embeddings to be set as the output embeddings for the model.

TYPE: Module

RETURNS DESCRIPTION

None.
Note

The output embeddings are used in the decoder layer of the XLMRobertaForCausalLM model. By setting new embeddings, users can customize the output layer of the model according to their specific requirements.

Example 
>>> model = XLMRobertaForCausalLM.from_pretrained('xlm-roberta-base')
>>> new_embeddings = torch.nn.Embedding(10, 768)
>>> model.set_output_embeddings(new_embeddings)
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
def set_output_embeddings(self, new_embeddings):
    """
    Sets the output embeddings for the XLMRobertaForCausalLM model.

    Args:
        self (XLMRobertaForCausalLM): The instance of the XLMRobertaForCausalLM class.
        new_embeddings (torch.nn.Module): The new embeddings to be set as the output embeddings for the model.

    Returns:
        None.

    Raises:
        None.

    Note:
        The output embeddings are used in the decoder layer of the XLMRobertaForCausalLM model.
        By setting new embeddings, users can customize the output layer of the model according to their specific
        requirements.

    Example:
        ```python
        >>> model = XLMRobertaForCausalLM.from_pretrained('xlm-roberta-base')
        >>> new_embeddings = torch.nn.Embedding(10, 768)
        >>> model.set_output_embeddings(new_embeddings)
        ```
    """
    self.lm_head.decoder = new_embeddings

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaForMaskedLM

Bases: XLMRobertaPreTrainedModel

XLMRobertaForMaskedLM

Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
class XLMRobertaForMaskedLM(XLMRobertaPreTrainedModel):
    """XLMRobertaForMaskedLM"""
    _tied_weights_keys = ["lm_head.decoder.weight", "lm_head.decoder.bias"]

    def __init__(self, config):
        """
        Initializes an instance of XLMRobertaForMaskedLM.

        Args:
            self: The instance of the class.
            config (object): The configuration object containing the settings for the model.
                It should have attributes like 'is_decoder' to control the behavior of the model.
                If 'is_decoder' is set to True, a warning message will be logged.
                Ensure that 'is_decoder' is set to False for bi-directional self-attention.

        Returns:
            None.

        Raises:
            None.
        """
        super().__init__(config)

        if config.is_decoder:
            logger.warning(
                "If you want to use `XLMRobertaForMaskedLM` make sure `config.is_decoder=False` for "
                "bi-directional self-attention."
            )

        self.roberta = XLMRobertaModel(config, add_pooling_layer=False)
        self.lm_head = XLMRobertaLMHead(config)

        # Initialize weights and apply final processing
        self.post_init()

    def get_output_embeddings(self):
        """Get the output embeddings for the XLM-Roberta model.

        Args:
            self (XLMRobertaForMaskedLM): The instance of the XLMRobertaForMaskedLM class.

        Returns:
            None.

        Raises:
            None.
        """
        return self.lm_head.decoder

    def set_output_embeddings(self, new_embeddings):
        """
        This method sets the output embeddings for the XLMRobertaForMaskedLM model.

        Args:
            self (XLMRobertaForMaskedLM): The instance of the XLMRobertaForMaskedLM class.
            new_embeddings (torch.nn.Module): The new embeddings to be set as the output embeddings for the model.
                It should be an instance of torch.nn.Module representing the new embeddings.

        Returns:
            None.

        Raises:
            TypeError: If the new_embeddings parameter is not an instance of torch.nn.Module.
            AttributeError: If the lm_head.decoder attribute does not exist or is not accessible within
                the XLMRobertaForMaskedLM instance.
        """
        self.lm_head.decoder = new_embeddings

    def forward(
        self,
        input_ids: Optional[mindspore.Tensor] = None,
        attention_mask: Optional[mindspore.Tensor] = None,
        token_type_ids: Optional[mindspore.Tensor] = None,
        position_ids: Optional[mindspore.Tensor] = None,
        head_mask: Optional[mindspore.Tensor] = None,
        inputs_embeds: Optional[mindspore.Tensor] = None,
        encoder_hidden_states: Optional[mindspore.Tensor] = None,
        encoder_attention_mask: Optional[mindspore.Tensor] = None,
        labels: Optional[mindspore.Tensor] = None,
        output_attentions: Optional[bool] = None,
        output_hidden_states: Optional[bool] = None,
        return_dict: Optional[bool] = None,
    ) -> Union[Tuple[mindspore.Tensor], MaskedLMOutput]:
        r"""
        Args:
            labels (`mindspore.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
                Labels for computing the masked language modeling loss. Indices should be in `[-100, 0, ...,
                config.vocab_size]` (see `input_ids` docstring) Tokens with indices set to `-100` are ignored (masked), the
                loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`
            kwargs (`Dict[str, any]`, optional, defaults to *{}*):
                Used to hide legacy arguments that have been deprecated.
        """
        return_dict = return_dict if return_dict is not None else self.config.use_return_dict

        outputs = self.roberta(
            input_ids,
            attention_mask=attention_mask,
            token_type_ids=token_type_ids,
            position_ids=position_ids,
            head_mask=head_mask,
            inputs_embeds=inputs_embeds,
            encoder_hidden_states=encoder_hidden_states,
            encoder_attention_mask=encoder_attention_mask,
            output_attentions=output_attentions,
            output_hidden_states=output_hidden_states,
            return_dict=return_dict,
        )
        sequence_output = outputs[0]
        prediction_scores = self.lm_head(sequence_output)

        masked_lm_loss = None
        if labels is not None:
            # move labels to correct device to enable model parallelism
            masked_lm_loss = ops.cross_entropy(prediction_scores.view(-1, self.config.vocab_size), labels.view(-1))

        if not return_dict:
            output = (prediction_scores,) + outputs[2:]
            return ((masked_lm_loss,) + output) if masked_lm_loss is not None else output

        return MaskedLMOutput(
            loss=masked_lm_loss,
            logits=prediction_scores,
            hidden_states=outputs.hidden_states,
            attentions=outputs.attentions,
        )

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaForMaskedLM.__init__(config)

Initializes an instance of XLMRobertaForMaskedLM.

PARAMETER DESCRIPTION
self

The instance of the class.
config

The configuration object containing the settings for the model. It should have attributes like 'is_decoder' to control the behavior of the model. If 'is_decoder' is set to True, a warning message will be logged. Ensure that 'is_decoder' is set to False for bi-directional self-attention.

TYPE: object

RETURNS DESCRIPTION

None.
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
def __init__(self, config):
    """
    Initializes an instance of XLMRobertaForMaskedLM.

    Args:
        self: The instance of the class.
        config (object): The configuration object containing the settings for the model.
            It should have attributes like 'is_decoder' to control the behavior of the model.
            If 'is_decoder' is set to True, a warning message will be logged.
            Ensure that 'is_decoder' is set to False for bi-directional self-attention.

    Returns:
        None.

    Raises:
        None.
    """
    super().__init__(config)

    if config.is_decoder:
        logger.warning(
            "If you want to use `XLMRobertaForMaskedLM` make sure `config.is_decoder=False` for "
            "bi-directional self-attention."
        )

    self.roberta = XLMRobertaModel(config, add_pooling_layer=False)
    self.lm_head = XLMRobertaLMHead(config)

    # Initialize weights and apply final processing
    self.post_init()

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaForMaskedLM.forward(input_ids=None, attention_mask=None, token_type_ids=None, position_ids=None, head_mask=None, inputs_embeds=None, encoder_hidden_states=None, encoder_attention_mask=None, labels=None, output_attentions=None, output_hidden_states=None, return_dict=None)

PARAMETER DESCRIPTION
labels

Labels for computing the masked language modeling loss. Indices should be in [-100, 0, ..., config.vocab_size] (see input_ids docstring) Tokens with indices set to -100 are ignored (masked), the loss is only computed for the tokens with labels in [0, ..., config.vocab_size]

TYPE: `mindspore.Tensor` of shape `(batch_size, sequence_length)`, *optional* DEFAULT: None

kwargs

Used to hide legacy arguments that have been deprecated.

TYPE: `Dict[str, any]`, optional, defaults to *{}*

Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
def forward(
    self,
    input_ids: Optional[mindspore.Tensor] = None,
    attention_mask: Optional[mindspore.Tensor] = None,
    token_type_ids: Optional[mindspore.Tensor] = None,
    position_ids: Optional[mindspore.Tensor] = None,
    head_mask: Optional[mindspore.Tensor] = None,
    inputs_embeds: Optional[mindspore.Tensor] = None,
    encoder_hidden_states: Optional[mindspore.Tensor] = None,
    encoder_attention_mask: Optional[mindspore.Tensor] = None,
    labels: Optional[mindspore.Tensor] = None,
    output_attentions: Optional[bool] = None,
    output_hidden_states: Optional[bool] = None,
    return_dict: Optional[bool] = None,
) -> Union[Tuple[mindspore.Tensor], MaskedLMOutput]:
    r"""
    Args:
        labels (`mindspore.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
            Labels for computing the masked language modeling loss. Indices should be in `[-100, 0, ...,
            config.vocab_size]` (see `input_ids` docstring) Tokens with indices set to `-100` are ignored (masked), the
            loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`
        kwargs (`Dict[str, any]`, optional, defaults to *{}*):
            Used to hide legacy arguments that have been deprecated.
    """
    return_dict = return_dict if return_dict is not None else self.config.use_return_dict

    outputs = self.roberta(
        input_ids,
        attention_mask=attention_mask,
        token_type_ids=token_type_ids,
        position_ids=position_ids,
        head_mask=head_mask,
        inputs_embeds=inputs_embeds,
        encoder_hidden_states=encoder_hidden_states,
        encoder_attention_mask=encoder_attention_mask,
        output_attentions=output_attentions,
        output_hidden_states=output_hidden_states,
        return_dict=return_dict,
    )
    sequence_output = outputs[0]
    prediction_scores = self.lm_head(sequence_output)

    masked_lm_loss = None
    if labels is not None:
        # move labels to correct device to enable model parallelism
        masked_lm_loss = ops.cross_entropy(prediction_scores.view(-1, self.config.vocab_size), labels.view(-1))

    if not return_dict:
        output = (prediction_scores,) + outputs[2:]
        return ((masked_lm_loss,) + output) if masked_lm_loss is not None else output

    return MaskedLMOutput(
        loss=masked_lm_loss,
        logits=prediction_scores,
        hidden_states=outputs.hidden_states,
        attentions=outputs.attentions,
    )

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaForMaskedLM.get_output_embeddings()

Get the output embeddings for the XLM-Roberta model.

PARAMETER DESCRIPTION
self

The instance of the XLMRobertaForMaskedLM class.

TYPE: XLMRobertaForMaskedLM

RETURNS DESCRIPTION

None.
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
def get_output_embeddings(self):
    """Get the output embeddings for the XLM-Roberta model.

    Args:
        self (XLMRobertaForMaskedLM): The instance of the XLMRobertaForMaskedLM class.

    Returns:
        None.

    Raises:
        None.
    """
    return self.lm_head.decoder

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaForMaskedLM.set_output_embeddings(new_embeddings)

This method sets the output embeddings for the XLMRobertaForMaskedLM model.

PARAMETER DESCRIPTION
self

The instance of the XLMRobertaForMaskedLM class.

TYPE: XLMRobertaForMaskedLM

new_embeddings

The new embeddings to be set as the output embeddings for the model. It should be an instance of torch.nn.Module representing the new embeddings.

TYPE: Module

RETURNS DESCRIPTION

None.
RAISES DESCRIPTION
TypeError

If the new_embeddings parameter is not an instance of torch.nn.Module.
AttributeError

If the lm_head.decoder attribute does not exist or is not accessible within the XLMRobertaForMaskedLM instance.
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
def set_output_embeddings(self, new_embeddings):
    """
    This method sets the output embeddings for the XLMRobertaForMaskedLM model.

    Args:
        self (XLMRobertaForMaskedLM): The instance of the XLMRobertaForMaskedLM class.
        new_embeddings (torch.nn.Module): The new embeddings to be set as the output embeddings for the model.
            It should be an instance of torch.nn.Module representing the new embeddings.

    Returns:
        None.

    Raises:
        TypeError: If the new_embeddings parameter is not an instance of torch.nn.Module.
        AttributeError: If the lm_head.decoder attribute does not exist or is not accessible within
            the XLMRobertaForMaskedLM instance.
    """
    self.lm_head.decoder = new_embeddings

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaForMultipleChoice

Bases: XLMRobertaPreTrainedModel

XLMRobertaForMultipleChoice

Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
class XLMRobertaForMultipleChoice(XLMRobertaPreTrainedModel):
    """XLMRobertaForMultipleChoice"""
    def __init__(self, config):
        """
        __init__

        Initialize the XLMRobertaForMultipleChoice model.

        Args:
            self: The instance of the class.
            config: An instance of the configuration class containing the model configuration.
                It is used to initialize the XLMRobertaModel, dropout, and classifier.
                It should be of type XLMRobertaConfig.

        Returns:
            None.

        Raises:
            None.
        """
        super().__init__(config)

        self.roberta = XLMRobertaModel(config)
        self.dropout = nn.Dropout(config.hidden_dropout_prob)
        self.classifier = nn.Linear(config.hidden_size, 1)

        # Initialize weights and apply final processing
        self.post_init()

    def forward(
        self,
        input_ids: Optional[mindspore.Tensor] = None,
        token_type_ids: Optional[mindspore.Tensor] = None,
        attention_mask: Optional[mindspore.Tensor] = None,
        labels: Optional[mindspore.Tensor] = None,
        position_ids: Optional[mindspore.Tensor] = None,
        head_mask: Optional[mindspore.Tensor] = None,
        inputs_embeds: Optional[mindspore.Tensor] = None,
        output_attentions: Optional[bool] = None,
        output_hidden_states: Optional[bool] = None,
        return_dict: Optional[bool] = None,
    ) -> Union[Tuple[mindspore.Tensor], MultipleChoiceModelOutput]:
        r"""
        Args:
            labels (`mindspore.Tensor` of shape `(batch_size,)`, *optional*):
                Labels for computing the multiple choice classification loss. Indices should be in `[0, ...,
                num_choices-1]` where `num_choices` is the size of the second dimension of the input tensors. (See
                `input_ids` above)
        """
        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
        num_choices = input_ids.shape[1] if input_ids is not None else inputs_embeds.shape[1]

        flat_input_ids = input_ids.view(-1, input_ids.size(-1)) if input_ids is not None else None
        flat_position_ids = position_ids.view(-1, position_ids.size(-1)) if position_ids is not None else None
        flat_token_type_ids = token_type_ids.view(-1, token_type_ids.size(-1)) if token_type_ids is not None else None
        flat_attention_mask = attention_mask.view(-1, attention_mask.size(-1)) if attention_mask is not None else None
        flat_inputs_embeds = (
            inputs_embeds.view(-1, inputs_embeds.size(-2), inputs_embeds.size(-1))
            if inputs_embeds is not None
            else None
        )

        outputs = self.roberta(
            flat_input_ids,
            position_ids=flat_position_ids,
            token_type_ids=flat_token_type_ids,
            attention_mask=flat_attention_mask,
            head_mask=head_mask,
            inputs_embeds=flat_inputs_embeds,
            output_attentions=output_attentions,
            output_hidden_states=output_hidden_states,
            return_dict=return_dict,
        )
        pooled_output = outputs[1]

        pooled_output = self.dropout(pooled_output)
        logits = self.classifier(pooled_output)
        reshaped_logits = logits.view(-1, num_choices)

        loss = None
        if labels is not None:
            # move labels to correct device to enable model parallelism
            loss = ops.cross_entropy(reshaped_logits, labels)

        if not return_dict:
            output = (reshaped_logits,) + outputs[2:]
            return ((loss,) + output) if loss is not None else output

        return MultipleChoiceModelOutput(
            loss=loss,
            logits=reshaped_logits,
            hidden_states=outputs.hidden_states,
            attentions=outputs.attentions,
        )

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaForMultipleChoice.__init__(config)

init

Initialize the XLMRobertaForMultipleChoice model.

PARAMETER DESCRIPTION
self

The instance of the class.
config

An instance of the configuration class containing the model configuration. It is used to initialize the XLMRobertaModel, dropout, and classifier. It should be of type XLMRobertaConfig.
RETURNS DESCRIPTION

None.
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
def __init__(self, config):
    """
    __init__

    Initialize the XLMRobertaForMultipleChoice model.

    Args:
        self: The instance of the class.
        config: An instance of the configuration class containing the model configuration.
            It is used to initialize the XLMRobertaModel, dropout, and classifier.
            It should be of type XLMRobertaConfig.

    Returns:
        None.

    Raises:
        None.
    """
    super().__init__(config)

    self.roberta = XLMRobertaModel(config)
    self.dropout = nn.Dropout(config.hidden_dropout_prob)
    self.classifier = nn.Linear(config.hidden_size, 1)

    # Initialize weights and apply final processing
    self.post_init()

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaForMultipleChoice.forward(input_ids=None, token_type_ids=None, attention_mask=None, labels=None, position_ids=None, head_mask=None, inputs_embeds=None, output_attentions=None, output_hidden_states=None, return_dict=None)

PARAMETER DESCRIPTION
labels

Labels for computing the multiple choice classification loss. Indices should be in [0, ..., num_choices-1] where num_choices is the size of the second dimension of the input tensors. (See input_ids above)

TYPE: `mindspore.Tensor` of shape `(batch_size,)`, *optional* DEFAULT: None

Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
def forward(
    self,
    input_ids: Optional[mindspore.Tensor] = None,
    token_type_ids: Optional[mindspore.Tensor] = None,
    attention_mask: Optional[mindspore.Tensor] = None,
    labels: Optional[mindspore.Tensor] = None,
    position_ids: Optional[mindspore.Tensor] = None,
    head_mask: Optional[mindspore.Tensor] = None,
    inputs_embeds: Optional[mindspore.Tensor] = None,
    output_attentions: Optional[bool] = None,
    output_hidden_states: Optional[bool] = None,
    return_dict: Optional[bool] = None,
) -> Union[Tuple[mindspore.Tensor], MultipleChoiceModelOutput]:
    r"""
    Args:
        labels (`mindspore.Tensor` of shape `(batch_size,)`, *optional*):
            Labels for computing the multiple choice classification loss. Indices should be in `[0, ...,
            num_choices-1]` where `num_choices` is the size of the second dimension of the input tensors. (See
            `input_ids` above)
    """
    return_dict = return_dict if return_dict is not None else self.config.use_return_dict
    num_choices = input_ids.shape[1] if input_ids is not None else inputs_embeds.shape[1]

    flat_input_ids = input_ids.view(-1, input_ids.size(-1)) if input_ids is not None else None
    flat_position_ids = position_ids.view(-1, position_ids.size(-1)) if position_ids is not None else None
    flat_token_type_ids = token_type_ids.view(-1, token_type_ids.size(-1)) if token_type_ids is not None else None
    flat_attention_mask = attention_mask.view(-1, attention_mask.size(-1)) if attention_mask is not None else None
    flat_inputs_embeds = (
        inputs_embeds.view(-1, inputs_embeds.size(-2), inputs_embeds.size(-1))
        if inputs_embeds is not None
        else None
    )

    outputs = self.roberta(
        flat_input_ids,
        position_ids=flat_position_ids,
        token_type_ids=flat_token_type_ids,
        attention_mask=flat_attention_mask,
        head_mask=head_mask,
        inputs_embeds=flat_inputs_embeds,
        output_attentions=output_attentions,
        output_hidden_states=output_hidden_states,
        return_dict=return_dict,
    )
    pooled_output = outputs[1]

    pooled_output = self.dropout(pooled_output)
    logits = self.classifier(pooled_output)
    reshaped_logits = logits.view(-1, num_choices)

    loss = None
    if labels is not None:
        # move labels to correct device to enable model parallelism
        loss = ops.cross_entropy(reshaped_logits, labels)

    if not return_dict:
        output = (reshaped_logits,) + outputs[2:]
        return ((loss,) + output) if loss is not None else output

    return MultipleChoiceModelOutput(
        loss=loss,
        logits=reshaped_logits,
        hidden_states=outputs.hidden_states,
        attentions=outputs.attentions,
    )

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaForQuestionAnswering

Bases: XLMRobertaPreTrainedModel

XLMRobertaForQuestionAnswering

Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
class XLMRobertaForQuestionAnswering(XLMRobertaPreTrainedModel):
    """XLMRobertaForQuestionAnswering"""
    def __init__(self, config):
        """
        Initializes the XLMRobertaForQuestionAnswering class.

        Args:
            self (XLMRobertaForQuestionAnswering): The instance of the XLMRobertaForQuestionAnswering class.
            config (XLMRobertaConfig): The configuration object for the XLM-RoBERTa model.
                It contains various parameters for model initialization, such as num_labels, hidden_size, and more.

        Returns:
            None.

        Raises:
            TypeError: If the provided config is not of type XLMRobertaConfig.
            ValueError: If the number of labels in the config is not a positive integer.
        """
        super().__init__(config)
        self.num_labels = config.num_labels

        self.roberta = XLMRobertaModel(config, add_pooling_layer=False)
        self.qa_outputs = nn.Linear(config.hidden_size, config.num_labels)

        # Initialize weights and apply final processing
        self.post_init()

    def forward(
        self,
        input_ids: Optional[mindspore.Tensor] = None,
        attention_mask: Optional[mindspore.Tensor] = None,
        token_type_ids: Optional[mindspore.Tensor] = None,
        position_ids: Optional[mindspore.Tensor] = None,
        head_mask: Optional[mindspore.Tensor] = None,
        inputs_embeds: Optional[mindspore.Tensor] = None,
        start_positions: Optional[mindspore.Tensor] = None,
        end_positions: Optional[mindspore.Tensor] = None,
        output_attentions: Optional[bool] = None,
        output_hidden_states: Optional[bool] = None,
        return_dict: Optional[bool] = None,
    ) -> Union[Tuple[mindspore.Tensor], QuestionAnsweringModelOutput]:
        r"""
        Args:
            start_positions (`mindspore.Tensor` of shape `(batch_size,)`, *optional*):
                Labels for position (index) of the start of the labelled span for computing the token classification loss.
                Positions are clamped to the length of the sequence (`sequence_length`). Position outside of the sequence
                are not taken into account for computing the loss.
            end_positions (`mindspore.Tensor` of shape `(batch_size,)`, *optional*):
                Labels for position (index) of the end of the labelled span for computing the token classification loss.
                Positions are clamped to the length of the sequence (`sequence_length`). Position outside of the sequence
                are not taken into account for computing the loss.
        """
        return_dict = return_dict if return_dict is not None else self.config.use_return_dict

        outputs = self.roberta(
            input_ids,
            attention_mask=attention_mask,
            token_type_ids=token_type_ids,
            position_ids=position_ids,
            head_mask=head_mask,
            inputs_embeds=inputs_embeds,
            output_attentions=output_attentions,
            output_hidden_states=output_hidden_states,
            return_dict=return_dict,
        )

        sequence_output = outputs[0]

        logits = self.qa_outputs(sequence_output)
        start_logits, end_logits = logits.split(1, dim=-1)
        start_logits = start_logits.squeeze(-1)
        end_logits = end_logits.squeeze(-1)

        total_loss = None
        if start_positions is not None and end_positions is not None:
            # If we are on multi-GPU, split add a dimension
            if len(start_positions.shape) > 1:
                start_positions = start_positions.squeeze(-1)
            if len(end_positions.shape) > 1:
                end_positions = end_positions.squeeze(-1)
            # sometimes the start/end positions are outside our model inputs, we ignore these terms
            ignored_index = start_logits.size(1)
            start_positions = start_positions.clamp(0, ignored_index)
            end_positions = end_positions.clamp(0, ignored_index)

            start_loss = ops.cross_entropy(start_logits, start_positions, ignore_index=ignored_index)
            end_loss = ops.cross_entropy(end_logits, end_positions, ignore_index=ignored_index)
            total_loss = (start_loss + end_loss) / 2

        if not return_dict:
            output = (start_logits, end_logits) + outputs[2:]
            return ((total_loss,) + output) if total_loss is not None else output

        return QuestionAnsweringModelOutput(
            loss=total_loss,
            start_logits=start_logits,
            end_logits=end_logits,
            hidden_states=outputs.hidden_states,
            attentions=outputs.attentions,
        )

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaForQuestionAnswering.__init__(config)

Initializes the XLMRobertaForQuestionAnswering class.

PARAMETER DESCRIPTION
self

The instance of the XLMRobertaForQuestionAnswering class.

TYPE: XLMRobertaForQuestionAnswering

config

The configuration object for the XLM-RoBERTa model. It contains various parameters for model initialization, such as num_labels, hidden_size, and more.

TYPE: XLMRobertaConfig

RETURNS DESCRIPTION

None.
RAISES DESCRIPTION
TypeError

If the provided config is not of type XLMRobertaConfig.
ValueError

If the number of labels in the config is not a positive integer.
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
def __init__(self, config):
    """
    Initializes the XLMRobertaForQuestionAnswering class.

    Args:
        self (XLMRobertaForQuestionAnswering): The instance of the XLMRobertaForQuestionAnswering class.
        config (XLMRobertaConfig): The configuration object for the XLM-RoBERTa model.
            It contains various parameters for model initialization, such as num_labels, hidden_size, and more.

    Returns:
        None.

    Raises:
        TypeError: If the provided config is not of type XLMRobertaConfig.
        ValueError: If the number of labels in the config is not a positive integer.
    """
    super().__init__(config)
    self.num_labels = config.num_labels

    self.roberta = XLMRobertaModel(config, add_pooling_layer=False)
    self.qa_outputs = nn.Linear(config.hidden_size, config.num_labels)

    # Initialize weights and apply final processing
    self.post_init()

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaForQuestionAnswering.forward(input_ids=None, attention_mask=None, token_type_ids=None, position_ids=None, head_mask=None, inputs_embeds=None, start_positions=None, end_positions=None, output_attentions=None, output_hidden_states=None, return_dict=None)

PARAMETER DESCRIPTION
start_positions

Labels for position (index) of the start of the labelled span for computing the token classification loss. Positions are clamped to the length of the sequence (sequence_length). Position outside of the sequence are not taken into account for computing the loss.

TYPE: `mindspore.Tensor` of shape `(batch_size,)`, *optional* DEFAULT: None

end_positions

Labels for position (index) of the end of the labelled span for computing the token classification loss. Positions are clamped to the length of the sequence (sequence_length). Position outside of the sequence are not taken into account for computing the loss.

TYPE: `mindspore.Tensor` of shape `(batch_size,)`, *optional* DEFAULT: None

Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
def forward(
    self,
    input_ids: Optional[mindspore.Tensor] = None,
    attention_mask: Optional[mindspore.Tensor] = None,
    token_type_ids: Optional[mindspore.Tensor] = None,
    position_ids: Optional[mindspore.Tensor] = None,
    head_mask: Optional[mindspore.Tensor] = None,
    inputs_embeds: Optional[mindspore.Tensor] = None,
    start_positions: Optional[mindspore.Tensor] = None,
    end_positions: Optional[mindspore.Tensor] = None,
    output_attentions: Optional[bool] = None,
    output_hidden_states: Optional[bool] = None,
    return_dict: Optional[bool] = None,
) -> Union[Tuple[mindspore.Tensor], QuestionAnsweringModelOutput]:
    r"""
    Args:
        start_positions (`mindspore.Tensor` of shape `(batch_size,)`, *optional*):
            Labels for position (index) of the start of the labelled span for computing the token classification loss.
            Positions are clamped to the length of the sequence (`sequence_length`). Position outside of the sequence
            are not taken into account for computing the loss.
        end_positions (`mindspore.Tensor` of shape `(batch_size,)`, *optional*):
            Labels for position (index) of the end of the labelled span for computing the token classification loss.
            Positions are clamped to the length of the sequence (`sequence_length`). Position outside of the sequence
            are not taken into account for computing the loss.
    """
    return_dict = return_dict if return_dict is not None else self.config.use_return_dict

    outputs = self.roberta(
        input_ids,
        attention_mask=attention_mask,
        token_type_ids=token_type_ids,
        position_ids=position_ids,
        head_mask=head_mask,
        inputs_embeds=inputs_embeds,
        output_attentions=output_attentions,
        output_hidden_states=output_hidden_states,
        return_dict=return_dict,
    )

    sequence_output = outputs[0]

    logits = self.qa_outputs(sequence_output)
    start_logits, end_logits = logits.split(1, dim=-1)
    start_logits = start_logits.squeeze(-1)
    end_logits = end_logits.squeeze(-1)

    total_loss = None
    if start_positions is not None and end_positions is not None:
        # If we are on multi-GPU, split add a dimension
        if len(start_positions.shape) > 1:
            start_positions = start_positions.squeeze(-1)
        if len(end_positions.shape) > 1:
            end_positions = end_positions.squeeze(-1)
        # sometimes the start/end positions are outside our model inputs, we ignore these terms
        ignored_index = start_logits.size(1)
        start_positions = start_positions.clamp(0, ignored_index)
        end_positions = end_positions.clamp(0, ignored_index)

        start_loss = ops.cross_entropy(start_logits, start_positions, ignore_index=ignored_index)
        end_loss = ops.cross_entropy(end_logits, end_positions, ignore_index=ignored_index)
        total_loss = (start_loss + end_loss) / 2

    if not return_dict:
        output = (start_logits, end_logits) + outputs[2:]
        return ((total_loss,) + output) if total_loss is not None else output

    return QuestionAnsweringModelOutput(
        loss=total_loss,
        start_logits=start_logits,
        end_logits=end_logits,
        hidden_states=outputs.hidden_states,
        attentions=outputs.attentions,
    )

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaForSequenceClassification

Bases: XLMRobertaPreTrainedModel

XLMRobertaForSequenceClassification

Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
class XLMRobertaForSequenceClassification(XLMRobertaPreTrainedModel):
    """XLMRobertaForSequenceClassification"""
    def __init__(self, config):
        """
        Initializes an instance of XLMRobertaForSequenceClassification.

        Args:
            self (object): The instance of the class.
            config (object):
                The configuration object containing the model hyperparameters and settings.

                - Type: XLMRobertaConfig
                - Purpose: Specifies the configuration for the XLM-Roberta model.
                - Restrictions: Must be a valid instance of XLMRobertaConfig.

        Returns:
            None.

        Raises:
            None.
        """
        super().__init__(config)
        self.num_labels = config.num_labels
        self.config = config

        self.roberta = XLMRobertaModel(config, add_pooling_layer=False)
        self.classifier = XLMRobertaClassificationHead(config)

        # Initialize weights and apply final processing
        self.post_init()

    def forward(
        self,
        input_ids: Optional[mindspore.Tensor] = None,
        attention_mask: Optional[mindspore.Tensor] = None,
        token_type_ids: Optional[mindspore.Tensor] = None,
        position_ids: Optional[mindspore.Tensor] = None,
        head_mask: Optional[mindspore.Tensor] = None,
        inputs_embeds: Optional[mindspore.Tensor] = None,
        labels: Optional[mindspore.Tensor] = None,
        output_attentions: Optional[bool] = None,
        output_hidden_states: Optional[bool] = None,
        return_dict: Optional[bool] = None,
    ) -> Union[Tuple[mindspore.Tensor], SequenceClassifierOutput]:
        r"""
        Args:
            labels (`mindspore.Tensor` of shape `(batch_size,)`, *optional*):
                Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
                config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
                `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
        """
        return_dict = return_dict if return_dict is not None else self.config.use_return_dict

        outputs = self.roberta(
            input_ids,
            attention_mask=attention_mask,
            token_type_ids=token_type_ids,
            position_ids=position_ids,
            head_mask=head_mask,
            inputs_embeds=inputs_embeds,
            output_attentions=output_attentions,
            output_hidden_states=output_hidden_states,
            return_dict=return_dict,
        )
        sequence_output = outputs[0]
        logits = self.classifier(sequence_output)

        loss = None
        if labels is not None:
            # move labels to correct device to enable model parallelism
            if self.config.problem_type is None:
                if self.num_labels == 1:
                    self.config.problem_type = "regression"
                elif self.num_labels > 1 and labels.dtype in (mindspore.int64, mindspore.int32):
                    self.config.problem_type = "single_label_classification"
                else:
                    self.config.problem_type = "multi_label_classification"

            if self.config.problem_type == "regression":
                if self.num_labels == 1:
                    loss = ops.mse_loss(logits.squeeze(), labels.squeeze())
                else:
                    loss = ops.mse_loss(logits, labels)
            elif self.config.problem_type == "single_label_classification":
                loss = ops.cross_entropy(logits.view(-1, self.num_labels), labels.view(-1))
            elif self.config.problem_type == "multi_label_classification":
                loss = ops.binary_cross_entropy_with_logits(logits, labels)

        if not return_dict:
            output = (logits,) + outputs[2:]
            return ((loss,) + output) if loss is not None else output

        return SequenceClassifierOutput(
            loss=loss,
            logits=logits,
            hidden_states=outputs.hidden_states,
            attentions=outputs.attentions,
        )

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaForSequenceClassification.__init__(config)

Initializes an instance of XLMRobertaForSequenceClassification.

PARAMETER DESCRIPTION
self

The instance of the class.

TYPE: object

config

The configuration object containing the model hyperparameters and settings.

  • Type: XLMRobertaConfig
  • Purpose: Specifies the configuration for the XLM-Roberta model.
  • Restrictions: Must be a valid instance of XLMRobertaConfig.

TYPE: object

RETURNS DESCRIPTION

None.
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
def __init__(self, config):
    """
    Initializes an instance of XLMRobertaForSequenceClassification.

    Args:
        self (object): The instance of the class.
        config (object):
            The configuration object containing the model hyperparameters and settings.

            - Type: XLMRobertaConfig
            - Purpose: Specifies the configuration for the XLM-Roberta model.
            - Restrictions: Must be a valid instance of XLMRobertaConfig.

    Returns:
        None.

    Raises:
        None.
    """
    super().__init__(config)
    self.num_labels = config.num_labels
    self.config = config

    self.roberta = XLMRobertaModel(config, add_pooling_layer=False)
    self.classifier = XLMRobertaClassificationHead(config)

    # Initialize weights and apply final processing
    self.post_init()

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaForSequenceClassification.forward(input_ids=None, attention_mask=None, token_type_ids=None, position_ids=None, head_mask=None, inputs_embeds=None, labels=None, output_attentions=None, output_hidden_states=None, return_dict=None)

PARAMETER DESCRIPTION
labels

Labels for computing the sequence classification/regression loss. Indices should be in [0, ..., config.num_labels - 1]. If config.num_labels == 1 a regression loss is computed (Mean-Square loss), If config.num_labels > 1 a classification loss is computed (Cross-Entropy).

TYPE: `mindspore.Tensor` of shape `(batch_size,)`, *optional* DEFAULT: None

Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
def forward(
    self,
    input_ids: Optional[mindspore.Tensor] = None,
    attention_mask: Optional[mindspore.Tensor] = None,
    token_type_ids: Optional[mindspore.Tensor] = None,
    position_ids: Optional[mindspore.Tensor] = None,
    head_mask: Optional[mindspore.Tensor] = None,
    inputs_embeds: Optional[mindspore.Tensor] = None,
    labels: Optional[mindspore.Tensor] = None,
    output_attentions: Optional[bool] = None,
    output_hidden_states: Optional[bool] = None,
    return_dict: Optional[bool] = None,
) -> Union[Tuple[mindspore.Tensor], SequenceClassifierOutput]:
    r"""
    Args:
        labels (`mindspore.Tensor` of shape `(batch_size,)`, *optional*):
            Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
            config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
            `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
    """
    return_dict = return_dict if return_dict is not None else self.config.use_return_dict

    outputs = self.roberta(
        input_ids,
        attention_mask=attention_mask,
        token_type_ids=token_type_ids,
        position_ids=position_ids,
        head_mask=head_mask,
        inputs_embeds=inputs_embeds,
        output_attentions=output_attentions,
        output_hidden_states=output_hidden_states,
        return_dict=return_dict,
    )
    sequence_output = outputs[0]
    logits = self.classifier(sequence_output)

    loss = None
    if labels is not None:
        # move labels to correct device to enable model parallelism
        if self.config.problem_type is None:
            if self.num_labels == 1:
                self.config.problem_type = "regression"
            elif self.num_labels > 1 and labels.dtype in (mindspore.int64, mindspore.int32):
                self.config.problem_type = "single_label_classification"
            else:
                self.config.problem_type = "multi_label_classification"

        if self.config.problem_type == "regression":
            if self.num_labels == 1:
                loss = ops.mse_loss(logits.squeeze(), labels.squeeze())
            else:
                loss = ops.mse_loss(logits, labels)
        elif self.config.problem_type == "single_label_classification":
            loss = ops.cross_entropy(logits.view(-1, self.num_labels), labels.view(-1))
        elif self.config.problem_type == "multi_label_classification":
            loss = ops.binary_cross_entropy_with_logits(logits, labels)

    if not return_dict:
        output = (logits,) + outputs[2:]
        return ((loss,) + output) if loss is not None else output

    return SequenceClassifierOutput(
        loss=loss,
        logits=logits,
        hidden_states=outputs.hidden_states,
        attentions=outputs.attentions,
    )

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaForTokenClassification

Bases: XLMRobertaPreTrainedModel

XLMRobertaForTokenClassification

Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
class XLMRobertaForTokenClassification(XLMRobertaPreTrainedModel):
    """XLMRobertaForTokenClassification"""
    def __init__(self, config):
        """
        Initializes the XLMRobertaForTokenClassification model.

        Args:
            self: The instance of the XLMRobertaForTokenClassification class.
            config:
                An object containing configuration settings for the model.
                It must provide the following attributes:

                - num_labels (int): The number of labels for token classification.
                - classifier_dropout (float, optional): The dropout probability for the classifier layer.
                If not specified, it defaults to the hidden dropout probability specified in the configuration.
                - hidden_dropout_prob (float): The dropout probability for hidden layers.
                - hidden_size (int): The size of the hidden layers in the model.

        Returns:
            None.

        Raises:
            TypeError: If config is not provided or is not an instance of the expected configuration object.
            ValueError: If the required attributes (num_labels, hidden_dropout_prob, hidden_size) are missing
                from the config.
        """
        super().__init__(config)
        self.num_labels = config.num_labels

        self.roberta = XLMRobertaModel(config, add_pooling_layer=False)
        classifier_dropout = (
            config.classifier_dropout if config.classifier_dropout is not None else config.hidden_dropout_prob
        )
        self.dropout = nn.Dropout(p=classifier_dropout)
        self.classifier = nn.Linear(config.hidden_size, config.num_labels)

        # Initialize weights and apply final processing
        self.post_init()

    def forward(
        self,
        input_ids: Optional[mindspore.Tensor] = None,
        attention_mask: Optional[mindspore.Tensor] = None,
        token_type_ids: Optional[mindspore.Tensor] = None,
        position_ids: Optional[mindspore.Tensor] = None,
        head_mask: Optional[mindspore.Tensor] = None,
        inputs_embeds: Optional[mindspore.Tensor] = None,
        labels: Optional[mindspore.Tensor] = None,
        output_attentions: Optional[bool] = None,
        output_hidden_states: Optional[bool] = None,
        return_dict: Optional[bool] = None,
    ) -> Union[Tuple[mindspore.Tensor], TokenClassifierOutput]:
        r"""
        Args:
            labels (`mindspore.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
                Labels for computing the token classification loss. Indices should be in `[0, ..., config.num_labels - 1]`.
        """
        return_dict = return_dict if return_dict is not None else self.config.use_return_dict

        outputs = self.roberta(
            input_ids,
            attention_mask=attention_mask,
            token_type_ids=token_type_ids,
            position_ids=position_ids,
            head_mask=head_mask,
            inputs_embeds=inputs_embeds,
            output_attentions=output_attentions,
            output_hidden_states=output_hidden_states,
            return_dict=return_dict,
        )

        sequence_output = outputs[0]

        sequence_output = self.dropout(sequence_output)
        logits = self.classifier(sequence_output)

        loss = None
        if labels is not None:
            loss = ops.cross_entropy(logits.view(-1, self.num_labels), labels.view(-1))

        if not return_dict:
            output = (logits,) + outputs[2:]
            return ((loss,) + output) if loss is not None else output

        return TokenClassifierOutput(
            loss=loss,
            logits=logits,
            hidden_states=outputs.hidden_states,
            attentions=outputs.attentions,
        )

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaForTokenClassification.__init__(config)

Initializes the XLMRobertaForTokenClassification model.

PARAMETER DESCRIPTION
self

The instance of the XLMRobertaForTokenClassification class.
config

An object containing configuration settings for the model. It must provide the following attributes:

  • num_labels (int): The number of labels for token classification.
  • classifier_dropout (float, optional): The dropout probability for the classifier layer. If not specified, it defaults to the hidden dropout probability specified in the configuration.
  • hidden_dropout_prob (float): The dropout probability for hidden layers.
  • hidden_size (int): The size of the hidden layers in the model.
RETURNS DESCRIPTION

None.
RAISES DESCRIPTION
TypeError

If config is not provided or is not an instance of the expected configuration object.
ValueError

If the required attributes (num_labels, hidden_dropout_prob, hidden_size) are missing from the config.
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
def __init__(self, config):
    """
    Initializes the XLMRobertaForTokenClassification model.

    Args:
        self: The instance of the XLMRobertaForTokenClassification class.
        config:
            An object containing configuration settings for the model.
            It must provide the following attributes:

            - num_labels (int): The number of labels for token classification.
            - classifier_dropout (float, optional): The dropout probability for the classifier layer.
            If not specified, it defaults to the hidden dropout probability specified in the configuration.
            - hidden_dropout_prob (float): The dropout probability for hidden layers.
            - hidden_size (int): The size of the hidden layers in the model.

    Returns:
        None.

    Raises:
        TypeError: If config is not provided or is not an instance of the expected configuration object.
        ValueError: If the required attributes (num_labels, hidden_dropout_prob, hidden_size) are missing
            from the config.
    """
    super().__init__(config)
    self.num_labels = config.num_labels

    self.roberta = XLMRobertaModel(config, add_pooling_layer=False)
    classifier_dropout = (
        config.classifier_dropout if config.classifier_dropout is not None else config.hidden_dropout_prob
    )
    self.dropout = nn.Dropout(p=classifier_dropout)
    self.classifier = nn.Linear(config.hidden_size, config.num_labels)

    # Initialize weights and apply final processing
    self.post_init()

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaForTokenClassification.forward(input_ids=None, attention_mask=None, token_type_ids=None, position_ids=None, head_mask=None, inputs_embeds=None, labels=None, output_attentions=None, output_hidden_states=None, return_dict=None)

PARAMETER DESCRIPTION
labels

Labels for computing the token classification loss. Indices should be in [0, ..., config.num_labels - 1].

TYPE: `mindspore.Tensor` of shape `(batch_size, sequence_length)`, *optional* DEFAULT: None

Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
def forward(
    self,
    input_ids: Optional[mindspore.Tensor] = None,
    attention_mask: Optional[mindspore.Tensor] = None,
    token_type_ids: Optional[mindspore.Tensor] = None,
    position_ids: Optional[mindspore.Tensor] = None,
    head_mask: Optional[mindspore.Tensor] = None,
    inputs_embeds: Optional[mindspore.Tensor] = None,
    labels: Optional[mindspore.Tensor] = None,
    output_attentions: Optional[bool] = None,
    output_hidden_states: Optional[bool] = None,
    return_dict: Optional[bool] = None,
) -> Union[Tuple[mindspore.Tensor], TokenClassifierOutput]:
    r"""
    Args:
        labels (`mindspore.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
            Labels for computing the token classification loss. Indices should be in `[0, ..., config.num_labels - 1]`.
    """
    return_dict = return_dict if return_dict is not None else self.config.use_return_dict

    outputs = self.roberta(
        input_ids,
        attention_mask=attention_mask,
        token_type_ids=token_type_ids,
        position_ids=position_ids,
        head_mask=head_mask,
        inputs_embeds=inputs_embeds,
        output_attentions=output_attentions,
        output_hidden_states=output_hidden_states,
        return_dict=return_dict,
    )

    sequence_output = outputs[0]

    sequence_output = self.dropout(sequence_output)
    logits = self.classifier(sequence_output)

    loss = None
    if labels is not None:
        loss = ops.cross_entropy(logits.view(-1, self.num_labels), labels.view(-1))

    if not return_dict:
        output = (logits,) + outputs[2:]
        return ((loss,) + output) if loss is not None else output

    return TokenClassifierOutput(
        loss=loss,
        logits=logits,
        hidden_states=outputs.hidden_states,
        attentions=outputs.attentions,
    )

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaIntermediate

Bases: Module

XLMRobertaIntermediate

Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
class XLMRobertaIntermediate(nn.Module):
    """XLMRobertaIntermediate"""
    def __init__(self, config):
        """
        Initializes an instance of the XLMRobertaIntermediate class.

        Args:
            self: The instance of the XLMRobertaIntermediate class.
            config:
                Configuration object containing parameters for the intermediate layer.

                - Type: object
                - Purpose: Specifies the configuration settings for the intermediate layer.

        Returns:
            None

        Raises:
            TypeError: If the 'config' parameter is not provided.
            ValueError: If the 'hidden_act' attribute of the 'config' parameter is not a string or a
                valid activation function.
        """
        super().__init__()
        self.dense = nn.Linear(config.hidden_size, config.intermediate_size)
        if isinstance(config.hidden_act, str):
            self.intermediate_act_fn = ACT2FN[config.hidden_act]
        else:
            self.intermediate_act_fn = config.hidden_act

    def forward(self, hidden_states: mindspore.Tensor) -> mindspore.Tensor:
        """
        This method forwards the hidden states using the specified intermediate layers in the XLMRoberta model.

        Args:
            self (XLMRobertaIntermediate): The instance of the XLMRobertaIntermediate class.
            hidden_states (mindspore.Tensor): The tensor representing the hidden states to be processed.
                It should be of type mindspore.Tensor and must adhere to the input requirements of the intermediate
                layers.

        Returns:
            mindspore.Tensor: Returns the processed hidden states as a tensor of type mindspore.Tensor.

        Raises:
            None.
        """
        hidden_states = self.dense(hidden_states)
        hidden_states = self.intermediate_act_fn(hidden_states)
        return hidden_states

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaIntermediate.__init__(config)

Initializes an instance of the XLMRobertaIntermediate class.

PARAMETER DESCRIPTION
self

The instance of the XLMRobertaIntermediate class.
config

Configuration object containing parameters for the intermediate layer.

  • Type: object
  • Purpose: Specifies the configuration settings for the intermediate layer.
RETURNS DESCRIPTION

None
RAISES DESCRIPTION
TypeError

If the 'config' parameter is not provided.
ValueError

If the 'hidden_act' attribute of the 'config' parameter is not a string or a valid activation function.
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
def __init__(self, config):
    """
    Initializes an instance of the XLMRobertaIntermediate class.

    Args:
        self: The instance of the XLMRobertaIntermediate class.
        config:
            Configuration object containing parameters for the intermediate layer.

            - Type: object
            - Purpose: Specifies the configuration settings for the intermediate layer.

    Returns:
        None

    Raises:
        TypeError: If the 'config' parameter is not provided.
        ValueError: If the 'hidden_act' attribute of the 'config' parameter is not a string or a
            valid activation function.
    """
    super().__init__()
    self.dense = nn.Linear(config.hidden_size, config.intermediate_size)
    if isinstance(config.hidden_act, str):
        self.intermediate_act_fn = ACT2FN[config.hidden_act]
    else:
        self.intermediate_act_fn = config.hidden_act

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaIntermediate.forward(hidden_states)

This method forwards the hidden states using the specified intermediate layers in the XLMRoberta model.

PARAMETER DESCRIPTION
self

The instance of the XLMRobertaIntermediate class.

TYPE: XLMRobertaIntermediate

hidden_states

The tensor representing the hidden states to be processed. It should be of type mindspore.Tensor and must adhere to the input requirements of the intermediate layers.

TYPE: Tensor

RETURNS DESCRIPTION
Tensor

mindspore.Tensor: Returns the processed hidden states as a tensor of type mindspore.Tensor.
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
def forward(self, hidden_states: mindspore.Tensor) -> mindspore.Tensor:
    """
    This method forwards the hidden states using the specified intermediate layers in the XLMRoberta model.

    Args:
        self (XLMRobertaIntermediate): The instance of the XLMRobertaIntermediate class.
        hidden_states (mindspore.Tensor): The tensor representing the hidden states to be processed.
            It should be of type mindspore.Tensor and must adhere to the input requirements of the intermediate
            layers.

    Returns:
        mindspore.Tensor: Returns the processed hidden states as a tensor of type mindspore.Tensor.

    Raises:
        None.
    """
    hidden_states = self.dense(hidden_states)
    hidden_states = self.intermediate_act_fn(hidden_states)
    return hidden_states

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaLMHead

Bases: Module

Roberta Head for masked language modeling.

Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
class XLMRobertaLMHead(nn.Module):
    """Roberta Head for masked language modeling."""
    def __init__(self, config):
        """
        This method initializes an instance of the XLMRobertaLMHead class.

        Args:
            self: An instance of the XLMRobertaLMHead class.
            config: A configuration object containing parameters for initializing the XLMRobertaLMHead instance.
                It is of type 'config' and is used to set the hidden size, vocabulary size, and layer
                normalization epsilon for the XLMRobertaLMHead instance.

        Returns:
            None.

        Raises:
            None.
        """
        super().__init__()
        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
        self.layer_norm = nn.LayerNorm([config.hidden_size], eps=config.layer_norm_eps)

        self.decoder = nn.Linear(config.hidden_size, config.vocab_size)
        self.bias = Parameter(ops.zeros(config.vocab_size), 'bias')
        self.decoder.bias = self.bias

    def forward(self, features, **kwargs):
        """
        Construct the LM head for the XLM-Roberta model.

        Args:
            self (XLMRobertaLMHead): The instance of the XLMRobertaLMHead class.
            features (Tensor): The input features to be used for LM head forwardion.

        Returns:
            None.

        Raises:
            None
        """
        x = self.dense(features)
        x = ops.gelu(x)
        x = self.layer_norm(x)

        # project back to size of vocabulary with bias
        x = self.decoder(x)

        return x

    def _tie_weights(self):
        """
        This method ties the weights of the XLMRobertaLMHead decoder to the bias.

        Args:
            self (XLMRobertaLMHead): The instance of the XLMRobertaLMHead class.
                This parameter is used to access the decoder and its bias.

        Returns:
            None.

        Raises:
            None
        """
        # To tie those two weights if they get disconnected
        self.bias = self.decoder.bias

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaLMHead.__init__(config)

This method initializes an instance of the XLMRobertaLMHead class.

PARAMETER DESCRIPTION
self

An instance of the XLMRobertaLMHead class.
config

A configuration object containing parameters for initializing the XLMRobertaLMHead instance. It is of type 'config' and is used to set the hidden size, vocabulary size, and layer normalization epsilon for the XLMRobertaLMHead instance.
RETURNS DESCRIPTION

None.
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
def __init__(self, config):
    """
    This method initializes an instance of the XLMRobertaLMHead class.

    Args:
        self: An instance of the XLMRobertaLMHead class.
        config: A configuration object containing parameters for initializing the XLMRobertaLMHead instance.
            It is of type 'config' and is used to set the hidden size, vocabulary size, and layer
            normalization epsilon for the XLMRobertaLMHead instance.

    Returns:
        None.

    Raises:
        None.
    """
    super().__init__()
    self.dense = nn.Linear(config.hidden_size, config.hidden_size)
    self.layer_norm = nn.LayerNorm([config.hidden_size], eps=config.layer_norm_eps)

    self.decoder = nn.Linear(config.hidden_size, config.vocab_size)
    self.bias = Parameter(ops.zeros(config.vocab_size), 'bias')
    self.decoder.bias = self.bias

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaLMHead.forward(features, **kwargs)

Construct the LM head for the XLM-Roberta model.

PARAMETER DESCRIPTION
self

The instance of the XLMRobertaLMHead class.

TYPE: XLMRobertaLMHead

features

The input features to be used for LM head forwardion.

TYPE: Tensor

RETURNS DESCRIPTION

None.
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
def forward(self, features, **kwargs):
    """
    Construct the LM head for the XLM-Roberta model.

    Args:
        self (XLMRobertaLMHead): The instance of the XLMRobertaLMHead class.
        features (Tensor): The input features to be used for LM head forwardion.

    Returns:
        None.

    Raises:
        None
    """
    x = self.dense(features)
    x = ops.gelu(x)
    x = self.layer_norm(x)

    # project back to size of vocabulary with bias
    x = self.decoder(x)

    return x

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaLayer

Bases: Module

XLMRobertaLayer

Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
class XLMRobertaLayer(nn.Module):
    """XLMRobertaLayer"""
    def __init__(self, config):
        """
        This method initializes an instance of the XLMRobertaLayer class.

        Args:
            self: The instance of the XLMRobertaLayer class.
            config: An object containing configuration parameters for the XLMRobertaLayer instance.
                It should include the following attributes:

                - chunk_size_feed_forward: An integer specifying the chunk size for feed-forward processing.
                - is_decoder: A boolean indicating whether the model is used as a decoder.
                - add_cross_attention: A boolean indicating whether cross-attention is added to the model.

        Returns:
            None.

        Raises:
            ValueError: If add_cross_attention is True and the model is not configured as a decoder, a ValueError
                is raised indicating that XLMRobertaLayer should be used as a decoder model when cross attention is added.
        """
        super().__init__()
        self.chunk_size_feed_forward = config.chunk_size_feed_forward
        self.seq_len_dim = 1
        self.attention = XLMRobertaAttention(config)
        self.is_decoder = config.is_decoder
        self.add_cross_attention = config.add_cross_attention
        if self.add_cross_attention:
            if not self.is_decoder:
                raise ValueError(f"{self} should be used as a decoder model if cross attention is added")
            self.crossattention = XLMRobertaAttention(config, position_embedding_type="absolute")
        self.intermediate = XLMRobertaIntermediate(config)
        self.output = XLMRobertaOutput(config)

    def forward(
        self,
        hidden_states: mindspore.Tensor,
        attention_mask: Optional[mindspore.Tensor] = None,
        head_mask: Optional[mindspore.Tensor] = None,
        encoder_hidden_states: Optional[mindspore.Tensor] = None,
        encoder_attention_mask: Optional[mindspore.Tensor] = None,
        past_key_value: Optional[Tuple[Tuple[mindspore.Tensor]]] = None,
        output_attentions: Optional[bool] = False,
    ) -> Tuple[mindspore.Tensor]:
        """
        Method to forward the XLMRobertaLayer.

        Args:
            self: The instance of the XLMRobertaLayer class.
            hidden_states (mindspore.Tensor): The input hidden states to be processed.
            attention_mask (Optional[mindspore.Tensor]): Optional tensor containing attention mask values for the
                self-attention mechanism.
            head_mask (Optional[mindspore.Tensor]): Optional tensor containing head mask values for the
                self-attention mechanism.
            encoder_hidden_states (Optional[mindspore.Tensor]): Optional tensor containing hidden states
                from the encoder.
            encoder_attention_mask (Optional[mindspore.Tensor]): Optional tensor containing attention mask values
                for the encoder.
            past_key_value (Optional[Tuple[Tuple[mindspore.Tensor]]]): Optional tuple of past key and value tensors
                for speeding up inference.
            output_attentions (Optional[bool]): Flag indicating whether to output attention weights.

        Returns:
            Tuple[mindspore.Tensor]: A tuple containing the computed layer output tensor and any additional outputs
                depending on the decoder mode.

        Raises:
            ValueError: Raised if `encoder_hidden_states` are provided but cross-attention layers were not instantiated.
        """
        # decoder uni-directional self-attention cached key/values tuple is at positions 1,2
        self_attn_past_key_value = past_key_value[:2] if past_key_value is not None else None
        self_attention_outputs = self.attention(
            hidden_states,
            attention_mask,
            head_mask,
            output_attentions=output_attentions,
            past_key_value=self_attn_past_key_value,
        )
        attention_output = self_attention_outputs[0]

        # if decoder, the last output is tuple of self-attn cache
        if self.is_decoder:
            outputs = self_attention_outputs[1:-1]
            present_key_value = self_attention_outputs[-1]
        else:
            outputs = self_attention_outputs[1:]  # add self attentions if we output attention weights

        cross_attn_present_key_value = None
        if self.is_decoder and encoder_hidden_states is not None:
            if not hasattr(self, "crossattention"):
                raise ValueError(
                    f"If `encoder_hidden_states` are passed, {self} has to be instantiated with cross-attention layers"
                    " by setting `config.add_cross_attention=True`"
                )

            # cross_attn cached key/values tuple is at positions 3,4 of past_key_value tuple
            cross_attn_past_key_value = past_key_value[-2:] if past_key_value is not None else None
            cross_attention_outputs = self.crossattention(
                attention_output,
                attention_mask,
                head_mask,
                encoder_hidden_states,
                encoder_attention_mask,
                cross_attn_past_key_value,
                output_attentions,
            )
            attention_output = cross_attention_outputs[0]
            outputs = outputs + cross_attention_outputs[1:-1]  # add cross attentions if we output attention weights

            # add cross-attn cache to positions 3,4 of present_key_value tuple
            cross_attn_present_key_value = cross_attention_outputs[-1]
            present_key_value = present_key_value + cross_attn_present_key_value

        layer_output = apply_chunking_to_forward(
            self.feed_forward_chunk, self.chunk_size_feed_forward, self.seq_len_dim, attention_output
        )
        outputs = (layer_output,) + outputs

        # if decoder, return the attn key/values as the last output
        if self.is_decoder:
            outputs = outputs + (present_key_value,)

        return outputs

    def feed_forward_chunk(self, attention_output):
        """feed_forward_chunk"""
        intermediate_output = self.intermediate(attention_output)
        layer_output = self.output(intermediate_output, attention_output)
        return layer_output

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaLayer.__init__(config)

This method initializes an instance of the XLMRobertaLayer class.

PARAMETER DESCRIPTION
self

The instance of the XLMRobertaLayer class.
config

An object containing configuration parameters for the XLMRobertaLayer instance. It should include the following attributes:

  • chunk_size_feed_forward: An integer specifying the chunk size for feed-forward processing.
  • is_decoder: A boolean indicating whether the model is used as a decoder.
  • add_cross_attention: A boolean indicating whether cross-attention is added to the model.
RETURNS DESCRIPTION

None.
RAISES DESCRIPTION
ValueError

If add_cross_attention is True and the model is not configured as a decoder, a ValueError is raised indicating that XLMRobertaLayer should be used as a decoder model when cross attention is added.
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
def __init__(self, config):
    """
    This method initializes an instance of the XLMRobertaLayer class.

    Args:
        self: The instance of the XLMRobertaLayer class.
        config: An object containing configuration parameters for the XLMRobertaLayer instance.
            It should include the following attributes:

            - chunk_size_feed_forward: An integer specifying the chunk size for feed-forward processing.
            - is_decoder: A boolean indicating whether the model is used as a decoder.
            - add_cross_attention: A boolean indicating whether cross-attention is added to the model.

    Returns:
        None.

    Raises:
        ValueError: If add_cross_attention is True and the model is not configured as a decoder, a ValueError
            is raised indicating that XLMRobertaLayer should be used as a decoder model when cross attention is added.
    """
    super().__init__()
    self.chunk_size_feed_forward = config.chunk_size_feed_forward
    self.seq_len_dim = 1
    self.attention = XLMRobertaAttention(config)
    self.is_decoder = config.is_decoder
    self.add_cross_attention = config.add_cross_attention
    if self.add_cross_attention:
        if not self.is_decoder:
            raise ValueError(f"{self} should be used as a decoder model if cross attention is added")
        self.crossattention = XLMRobertaAttention(config, position_embedding_type="absolute")
    self.intermediate = XLMRobertaIntermediate(config)
    self.output = XLMRobertaOutput(config)

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaLayer.feed_forward_chunk(attention_output)

feed_forward_chunk

Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
729
730
731
732
733
def feed_forward_chunk(self, attention_output):
    """feed_forward_chunk"""
    intermediate_output = self.intermediate(attention_output)
    layer_output = self.output(intermediate_output, attention_output)
    return layer_output

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaLayer.forward(hidden_states, attention_mask=None, head_mask=None, encoder_hidden_states=None, encoder_attention_mask=None, past_key_value=None, output_attentions=False)

Method to forward the XLMRobertaLayer.

PARAMETER DESCRIPTION
self

The instance of the XLMRobertaLayer class.
hidden_states

The input hidden states to be processed.

TYPE: Tensor

attention_mask

Optional tensor containing attention mask values for the self-attention mechanism.

TYPE: Optional[Tensor] DEFAULT: None

head_mask

Optional tensor containing head mask values for the self-attention mechanism.

TYPE: Optional[Tensor] DEFAULT: None

encoder_hidden_states

Optional tensor containing hidden states from the encoder.

TYPE: Optional[Tensor] DEFAULT: None

encoder_attention_mask

Optional tensor containing attention mask values for the encoder.

TYPE: Optional[Tensor] DEFAULT: None

past_key_value

Optional tuple of past key and value tensors for speeding up inference.

TYPE: Optional[Tuple[Tuple[Tensor]]] DEFAULT: None

output_attentions

Flag indicating whether to output attention weights.

TYPE: Optional[bool] DEFAULT: False

RETURNS DESCRIPTION
Tuple[Tensor]

Tuple[mindspore.Tensor]: A tuple containing the computed layer output tensor and any additional outputs depending on the decoder mode.
RAISES DESCRIPTION
ValueError

Raised if encoder_hidden_states are provided but cross-attention layers were not instantiated.
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
def forward(
    self,
    hidden_states: mindspore.Tensor,
    attention_mask: Optional[mindspore.Tensor] = None,
    head_mask: Optional[mindspore.Tensor] = None,
    encoder_hidden_states: Optional[mindspore.Tensor] = None,
    encoder_attention_mask: Optional[mindspore.Tensor] = None,
    past_key_value: Optional[Tuple[Tuple[mindspore.Tensor]]] = None,
    output_attentions: Optional[bool] = False,
) -> Tuple[mindspore.Tensor]:
    """
    Method to forward the XLMRobertaLayer.

    Args:
        self: The instance of the XLMRobertaLayer class.
        hidden_states (mindspore.Tensor): The input hidden states to be processed.
        attention_mask (Optional[mindspore.Tensor]): Optional tensor containing attention mask values for the
            self-attention mechanism.
        head_mask (Optional[mindspore.Tensor]): Optional tensor containing head mask values for the
            self-attention mechanism.
        encoder_hidden_states (Optional[mindspore.Tensor]): Optional tensor containing hidden states
            from the encoder.
        encoder_attention_mask (Optional[mindspore.Tensor]): Optional tensor containing attention mask values
            for the encoder.
        past_key_value (Optional[Tuple[Tuple[mindspore.Tensor]]]): Optional tuple of past key and value tensors
            for speeding up inference.
        output_attentions (Optional[bool]): Flag indicating whether to output attention weights.

    Returns:
        Tuple[mindspore.Tensor]: A tuple containing the computed layer output tensor and any additional outputs
            depending on the decoder mode.

    Raises:
        ValueError: Raised if `encoder_hidden_states` are provided but cross-attention layers were not instantiated.
    """
    # decoder uni-directional self-attention cached key/values tuple is at positions 1,2
    self_attn_past_key_value = past_key_value[:2] if past_key_value is not None else None
    self_attention_outputs = self.attention(
        hidden_states,
        attention_mask,
        head_mask,
        output_attentions=output_attentions,
        past_key_value=self_attn_past_key_value,
    )
    attention_output = self_attention_outputs[0]

    # if decoder, the last output is tuple of self-attn cache
    if self.is_decoder:
        outputs = self_attention_outputs[1:-1]
        present_key_value = self_attention_outputs[-1]
    else:
        outputs = self_attention_outputs[1:]  # add self attentions if we output attention weights

    cross_attn_present_key_value = None
    if self.is_decoder and encoder_hidden_states is not None:
        if not hasattr(self, "crossattention"):
            raise ValueError(
                f"If `encoder_hidden_states` are passed, {self} has to be instantiated with cross-attention layers"
                " by setting `config.add_cross_attention=True`"
            )

        # cross_attn cached key/values tuple is at positions 3,4 of past_key_value tuple
        cross_attn_past_key_value = past_key_value[-2:] if past_key_value is not None else None
        cross_attention_outputs = self.crossattention(
            attention_output,
            attention_mask,
            head_mask,
            encoder_hidden_states,
            encoder_attention_mask,
            cross_attn_past_key_value,
            output_attentions,
        )
        attention_output = cross_attention_outputs[0]
        outputs = outputs + cross_attention_outputs[1:-1]  # add cross attentions if we output attention weights

        # add cross-attn cache to positions 3,4 of present_key_value tuple
        cross_attn_present_key_value = cross_attention_outputs[-1]
        present_key_value = present_key_value + cross_attn_present_key_value

    layer_output = apply_chunking_to_forward(
        self.feed_forward_chunk, self.chunk_size_feed_forward, self.seq_len_dim, attention_output
    )
    outputs = (layer_output,) + outputs

    # if decoder, return the attn key/values as the last output
    if self.is_decoder:
        outputs = outputs + (present_key_value,)

    return outputs

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaModel

Bases: XLMRobertaPreTrainedModel

The model can behave as an encoder (with only self-attention) as well as a decoder, in which case a layer of cross-attention is added between the self-attention layers, following the architecture described in Attention is all you need_ by Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser and Illia Polosukhin.

To behave as an decoder the model needs to be initialized with the is_decoder argument of the configuration set to True. To be used in a Seq2Seq model, the model needs to initialized with both is_decoder argument and add_cross_attention set to True; an encoder_hidden_states is then expected as an input to the forward pass.

.. _Attention is all you need: https://arxiv.org/abs/1706.03762

Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
 960
 961
 962
 963
 964
 965
 966
 967
 968
 969
 970
 971
 972
 973
 974
 975
 976
 977
 978
 979
 980
 981
 982
 983
 984
 985
 986
 987
 988
 989
 990
 991
 992
 993
 994
 995
 996
 997
 998
 999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
class XLMRobertaModel(XLMRobertaPreTrainedModel):
    """
    The model can behave as an encoder (with only self-attention) as well as a decoder, in which case a layer of
    cross-attention is added between the self-attention layers, following the architecture described in *Attention is
    all you need*_ by Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz
    Kaiser and Illia Polosukhin.

    To behave as an decoder the model needs to be initialized with the `is_decoder` argument of the configuration set
    to `True`. To be used in a Seq2Seq model, the model needs to initialized with both `is_decoder` argument and
    `add_cross_attention` set to `True`; an `encoder_hidden_states` is then expected as an input to the forward pass.

    .. _*Attention is all you need*: https://arxiv.org/abs/1706.03762

    """
    # Copied from transformers.models.bert.modeling_bert.BertModel.__init__ with Bert->XLMRoberta
    def __init__(self, config, add_pooling_layer=True):
        """
        Initializes an instance of the XLMRobertaModel class.

        Args:
            self (XLMRobertaModel): The instance of the class itself.
            config (XLMRobertaConfig): The configuration object that holds the model configuration settings.
            add_pooling_layer (bool): A flag indicating whether to add a pooling layer to the model. Defaults to True.

        Returns:
            None

        Raises:
            None
        """
        super().__init__(config)
        self.config = config
        self.embeddings = XLMRobertaEmbeddings(config)
        self.encoder = XLMRobertaEncoder(config)
        self.pooler = XLMRobertaPooler(config) if add_pooling_layer else None

        # Initialize weights and apply final processing
        self.post_init()

    def get_input_embeddings(self):
        """
        This method 'get_input_embeddings' is defined in the class 'XLMRobertaModel' and retrieves the input
        embeddings from the model.

        Args:
            self (XLMRobertaModel): The instance of the XLMRobertaModel class.
                This parameter is required to access the embeddings within the model.

        Returns:
            None: This method returns None as it simply retrieves the input embeddings without any further processing.

        Raises:
            None.
        """
        return self.embeddings.word_embeddings

    def set_input_embeddings(self, value):
        """
        Sets the input embeddings for the XLMRobertaModel.

        Args:
            self (XLMRobertaModel): The current instance of the XLMRobertaModel class.
            value: The new input embeddings to be set. This should be of type torch.Tensor.

        Returns:
            None.

        Raises:
            None.

        Note:
            The 'value' parameter should have the same dimensions as the current word_embeddings of the model.
            The input embeddings are used to represent the input tokens as vectors in the XLMRobertaModel.
            By setting new input embeddings, the model can be fine-tuned or updated with custom embeddings.

        Example:
            ```python
            >>> model = XLMRobertaModel()
            >>> embeddings = torch.tensor([[0.1, 0.2], [0.3, 0.4]])
            >>> model.set_input_embeddings(embeddings)
            ```
        """
        self.embeddings.word_embeddings = value

    def _prune_heads(self, heads_to_prune):
        """
        Prunes heads of the model. heads_to_prune: dict of {layer_num: list of heads to prune in this layer} See base
        class PreTrainedModel
        """
        for layer, heads in heads_to_prune.items():
            self.encoder.layer[layer].attention.prune_heads(heads)

    def forward(
        self,
        input_ids: Optional[mindspore.Tensor] = None,
        attention_mask: Optional[mindspore.Tensor] = None,
        token_type_ids: Optional[mindspore.Tensor] = None,
        position_ids: Optional[mindspore.Tensor] = None,
        head_mask: Optional[mindspore.Tensor] = None,
        inputs_embeds: Optional[mindspore.Tensor] = None,
        encoder_hidden_states: Optional[mindspore.Tensor] = None,
        encoder_attention_mask: Optional[mindspore.Tensor] = None,
        past_key_values: Optional[List[mindspore.Tensor]] = None,
        use_cache: Optional[bool] = None,
        output_attentions: Optional[bool] = None,
        output_hidden_states: Optional[bool] = None,
        return_dict: Optional[bool] = None,
    ) -> Union[Tuple[mindspore.Tensor], BaseModelOutputWithPoolingAndCrossAttentions]:
        r"""
        Args:
            encoder_hidden_states  (`mindspore.Tensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
                Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention if
                the model is configured as a decoder.
            encoder_attention_mask (`mindspore.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
                Mask to avoid performing attention on the padding token indices of the encoder input. This mask is used in
                the cross-attention if the model is configured as a decoder. Mask values selected in `[0, 1]`:

                - 1 for tokens that are **not masked**,
                - 0 for tokens that are **masked**.
            past_key_values (`tuple(tuple(mindspore.Tensor))` of length `config.n_layers` with each tuple having 4
                tensors of shape `(batch_size, num_heads, sequence_length - 1, embed_size_per_head)`):
                Contains precomputed key and value hidden states of the attention blocks. Can be used to speed up decoding.
                If `past_key_values` are used, the user can optionally input only the last `decoder_input_ids` (those that
                don't have their past key value states given to this model) of shape `(batch_size, 1)` instead of all
                `decoder_input_ids` of shape `(batch_size, sequence_length)`.
            use_cache (`bool`, *optional*):
                If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see
                `past_key_values`).
        """
        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
        output_hidden_states = (
            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
        )
        return_dict = return_dict if return_dict is not None else self.config.use_return_dict

        if self.config.is_decoder:
            use_cache = use_cache if use_cache is not None else self.config.use_cache
        else:
            use_cache = False

        if input_ids is not None and inputs_embeds is not None:
            raise ValueError("You cannot specify both input_ids and inputs_embeds at the same time")
        if input_ids is not None:
            self.warn_if_padding_and_no_attention_mask(input_ids, attention_mask)
            input_shape = input_ids.shape
        elif inputs_embeds is not None:
            input_shape = inputs_embeds.shape[:-1]
        else:
            raise ValueError("You have to specify either input_ids or inputs_embeds")

        batch_size, seq_length = input_shape

        # past_key_values_length
        past_key_values_length = past_key_values[0][0].shape[2] if past_key_values is not None else 0

        if attention_mask is None:
            attention_mask = ops.ones(((batch_size, seq_length + past_key_values_length)))

        if token_type_ids is None:
            if hasattr(self.embeddings, "token_type_ids"):
                buffered_token_type_ids = self.embeddings.token_type_ids[:, :seq_length]
                buffered_token_type_ids_expanded = buffered_token_type_ids.broadcast_to((batch_size, seq_length))
                token_type_ids = buffered_token_type_ids_expanded
            else:
                token_type_ids = ops.zeros(input_shape, dtype=mindspore.int64)

        # We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length]
        # ourselves in which case we just need to make it broadcastable to all heads.
        extended_attention_mask: mindspore.Tensor = self.get_extended_attention_mask(attention_mask, input_shape)

        # If a 2D or 3D attention mask is provided for the cross-attention
        # we need to make broadcastable to [batch_size, num_heads, seq_length, seq_length]
        if self.config.is_decoder and encoder_hidden_states is not None:
            encoder_batch_size, encoder_sequence_length, _ = encoder_hidden_states.shape
            encoder_hidden_shape = (encoder_batch_size, encoder_sequence_length)
            if encoder_attention_mask is None:
                encoder_attention_mask = ops.ones(encoder_hidden_shape)
            encoder_extended_attention_mask = self.invert_attention_mask(encoder_attention_mask)
        else:
            encoder_extended_attention_mask = None

        # Prepare head mask if needed
        # 1.0 in head_mask indicate we keep the head
        # attention_probs has shape bsz x n_heads x N x N
        # input head_mask has shape [num_heads] or [num_hidden_layers x num_heads]
        # and head_mask is converted to shape [num_hidden_layers x batch x num_heads x seq_length x seq_length]
        head_mask = self.get_head_mask(head_mask, self.config.num_hidden_layers)

        embedding_output = self.embeddings(
            input_ids=input_ids,
            position_ids=position_ids,
            token_type_ids=token_type_ids,
            inputs_embeds=inputs_embeds,
            past_key_values_length=past_key_values_length,
        )
        encoder_outputs = self.encoder(
            embedding_output,
            attention_mask=extended_attention_mask,
            head_mask=head_mask,
            encoder_hidden_states=encoder_hidden_states,
            encoder_attention_mask=encoder_extended_attention_mask,
            past_key_values=past_key_values,
            use_cache=use_cache,
            output_attentions=output_attentions,
            output_hidden_states=output_hidden_states,
            return_dict=return_dict,
        )
        sequence_output = encoder_outputs[0]
        pooled_output = self.pooler(sequence_output) if self.pooler is not None else None

        if not return_dict:
            return (sequence_output, pooled_output) + encoder_outputs[1:]

        return BaseModelOutputWithPoolingAndCrossAttentions(
            last_hidden_state=sequence_output,
            pooler_output=pooled_output,
            past_key_values=encoder_outputs.past_key_values,
            hidden_states=encoder_outputs.hidden_states,
            attentions=encoder_outputs.attentions,
            cross_attentions=encoder_outputs.cross_attentions,
        )

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaModel.__init__(config, add_pooling_layer=True)

Initializes an instance of the XLMRobertaModel class.

PARAMETER DESCRIPTION
self

The instance of the class itself.

TYPE: XLMRobertaModel

config

The configuration object that holds the model configuration settings.

TYPE: XLMRobertaConfig

add_pooling_layer

A flag indicating whether to add a pooling layer to the model. Defaults to True.

TYPE: bool DEFAULT: True

RETURNS DESCRIPTION

None
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
def __init__(self, config, add_pooling_layer=True):
    """
    Initializes an instance of the XLMRobertaModel class.

    Args:
        self (XLMRobertaModel): The instance of the class itself.
        config (XLMRobertaConfig): The configuration object that holds the model configuration settings.
        add_pooling_layer (bool): A flag indicating whether to add a pooling layer to the model. Defaults to True.

    Returns:
        None

    Raises:
        None
    """
    super().__init__(config)
    self.config = config
    self.embeddings = XLMRobertaEmbeddings(config)
    self.encoder = XLMRobertaEncoder(config)
    self.pooler = XLMRobertaPooler(config) if add_pooling_layer else None

    # Initialize weights and apply final processing
    self.post_init()

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaModel.forward(input_ids=None, attention_mask=None, token_type_ids=None, position_ids=None, head_mask=None, inputs_embeds=None, encoder_hidden_states=None, encoder_attention_mask=None, past_key_values=None, use_cache=None, output_attentions=None, output_hidden_states=None, return_dict=None)

PARAMETER DESCRIPTION
encoder_hidden_states

Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention if the model is configured as a decoder.

TYPE: (`mindspore.Tensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional* DEFAULT: None

encoder_attention_mask

Mask to avoid performing attention on the padding token indices of the encoder input. This mask is used in the cross-attention if the model is configured as a decoder. Mask values selected in [0, 1]:

  • 1 for tokens that are not masked,
  • 0 for tokens that are masked.

TYPE: `mindspore.Tensor` of shape `(batch_size, sequence_length)`, *optional* DEFAULT: None

use_cache

If set to True, past_key_values key value states are returned and can be used to speed up decoding (see past_key_values).

TYPE: `bool`, *optional* DEFAULT: None

Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
def forward(
    self,
    input_ids: Optional[mindspore.Tensor] = None,
    attention_mask: Optional[mindspore.Tensor] = None,
    token_type_ids: Optional[mindspore.Tensor] = None,
    position_ids: Optional[mindspore.Tensor] = None,
    head_mask: Optional[mindspore.Tensor] = None,
    inputs_embeds: Optional[mindspore.Tensor] = None,
    encoder_hidden_states: Optional[mindspore.Tensor] = None,
    encoder_attention_mask: Optional[mindspore.Tensor] = None,
    past_key_values: Optional[List[mindspore.Tensor]] = None,
    use_cache: Optional[bool] = None,
    output_attentions: Optional[bool] = None,
    output_hidden_states: Optional[bool] = None,
    return_dict: Optional[bool] = None,
) -> Union[Tuple[mindspore.Tensor], BaseModelOutputWithPoolingAndCrossAttentions]:
    r"""
    Args:
        encoder_hidden_states  (`mindspore.Tensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
            Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention if
            the model is configured as a decoder.
        encoder_attention_mask (`mindspore.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
            Mask to avoid performing attention on the padding token indices of the encoder input. This mask is used in
            the cross-attention if the model is configured as a decoder. Mask values selected in `[0, 1]`:

            - 1 for tokens that are **not masked**,
            - 0 for tokens that are **masked**.
        past_key_values (`tuple(tuple(mindspore.Tensor))` of length `config.n_layers` with each tuple having 4
            tensors of shape `(batch_size, num_heads, sequence_length - 1, embed_size_per_head)`):
            Contains precomputed key and value hidden states of the attention blocks. Can be used to speed up decoding.
            If `past_key_values` are used, the user can optionally input only the last `decoder_input_ids` (those that
            don't have their past key value states given to this model) of shape `(batch_size, 1)` instead of all
            `decoder_input_ids` of shape `(batch_size, sequence_length)`.
        use_cache (`bool`, *optional*):
            If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see
            `past_key_values`).
    """
    output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
    output_hidden_states = (
        output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
    )
    return_dict = return_dict if return_dict is not None else self.config.use_return_dict

    if self.config.is_decoder:
        use_cache = use_cache if use_cache is not None else self.config.use_cache
    else:
        use_cache = False

    if input_ids is not None and inputs_embeds is not None:
        raise ValueError("You cannot specify both input_ids and inputs_embeds at the same time")
    if input_ids is not None:
        self.warn_if_padding_and_no_attention_mask(input_ids, attention_mask)
        input_shape = input_ids.shape
    elif inputs_embeds is not None:
        input_shape = inputs_embeds.shape[:-1]
    else:
        raise ValueError("You have to specify either input_ids or inputs_embeds")

    batch_size, seq_length = input_shape

    # past_key_values_length
    past_key_values_length = past_key_values[0][0].shape[2] if past_key_values is not None else 0

    if attention_mask is None:
        attention_mask = ops.ones(((batch_size, seq_length + past_key_values_length)))

    if token_type_ids is None:
        if hasattr(self.embeddings, "token_type_ids"):
            buffered_token_type_ids = self.embeddings.token_type_ids[:, :seq_length]
            buffered_token_type_ids_expanded = buffered_token_type_ids.broadcast_to((batch_size, seq_length))
            token_type_ids = buffered_token_type_ids_expanded
        else:
            token_type_ids = ops.zeros(input_shape, dtype=mindspore.int64)

    # We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length]
    # ourselves in which case we just need to make it broadcastable to all heads.
    extended_attention_mask: mindspore.Tensor = self.get_extended_attention_mask(attention_mask, input_shape)

    # If a 2D or 3D attention mask is provided for the cross-attention
    # we need to make broadcastable to [batch_size, num_heads, seq_length, seq_length]
    if self.config.is_decoder and encoder_hidden_states is not None:
        encoder_batch_size, encoder_sequence_length, _ = encoder_hidden_states.shape
        encoder_hidden_shape = (encoder_batch_size, encoder_sequence_length)
        if encoder_attention_mask is None:
            encoder_attention_mask = ops.ones(encoder_hidden_shape)
        encoder_extended_attention_mask = self.invert_attention_mask(encoder_attention_mask)
    else:
        encoder_extended_attention_mask = None

    # Prepare head mask if needed
    # 1.0 in head_mask indicate we keep the head
    # attention_probs has shape bsz x n_heads x N x N
    # input head_mask has shape [num_heads] or [num_hidden_layers x num_heads]
    # and head_mask is converted to shape [num_hidden_layers x batch x num_heads x seq_length x seq_length]
    head_mask = self.get_head_mask(head_mask, self.config.num_hidden_layers)

    embedding_output = self.embeddings(
        input_ids=input_ids,
        position_ids=position_ids,
        token_type_ids=token_type_ids,
        inputs_embeds=inputs_embeds,
        past_key_values_length=past_key_values_length,
    )
    encoder_outputs = self.encoder(
        embedding_output,
        attention_mask=extended_attention_mask,
        head_mask=head_mask,
        encoder_hidden_states=encoder_hidden_states,
        encoder_attention_mask=encoder_extended_attention_mask,
        past_key_values=past_key_values,
        use_cache=use_cache,
        output_attentions=output_attentions,
        output_hidden_states=output_hidden_states,
        return_dict=return_dict,
    )
    sequence_output = encoder_outputs[0]
    pooled_output = self.pooler(sequence_output) if self.pooler is not None else None

    if not return_dict:
        return (sequence_output, pooled_output) + encoder_outputs[1:]

    return BaseModelOutputWithPoolingAndCrossAttentions(
        last_hidden_state=sequence_output,
        pooler_output=pooled_output,
        past_key_values=encoder_outputs.past_key_values,
        hidden_states=encoder_outputs.hidden_states,
        attentions=encoder_outputs.attentions,
        cross_attentions=encoder_outputs.cross_attentions,
    )

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaModel.get_input_embeddings()

This method 'get_input_embeddings' is defined in the class 'XLMRobertaModel' and retrieves the input embeddings from the model.

PARAMETER DESCRIPTION
self

The instance of the XLMRobertaModel class. This parameter is required to access the embeddings within the model.

TYPE: XLMRobertaModel

RETURNS DESCRIPTION
None

This method returns None as it simply retrieves the input embeddings without any further processing.
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
 999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
def get_input_embeddings(self):
    """
    This method 'get_input_embeddings' is defined in the class 'XLMRobertaModel' and retrieves the input
    embeddings from the model.

    Args:
        self (XLMRobertaModel): The instance of the XLMRobertaModel class.
            This parameter is required to access the embeddings within the model.

    Returns:
        None: This method returns None as it simply retrieves the input embeddings without any further processing.

    Raises:
        None.
    """
    return self.embeddings.word_embeddings

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaModel.set_input_embeddings(value)

Sets the input embeddings for the XLMRobertaModel.

PARAMETER DESCRIPTION
self

The current instance of the XLMRobertaModel class.

TYPE: XLMRobertaModel

value

The new input embeddings to be set. This should be of type torch.Tensor.
RETURNS DESCRIPTION

None.
Note

The 'value' parameter should have the same dimensions as the current word_embeddings of the model. The input embeddings are used to represent the input tokens as vectors in the XLMRobertaModel. By setting new input embeddings, the model can be fine-tuned or updated with custom embeddings.

Example 
>>> model = XLMRobertaModel()
>>> embeddings = torch.tensor([[0.1, 0.2], [0.3, 0.4]])
>>> model.set_input_embeddings(embeddings)
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
def set_input_embeddings(self, value):
    """
    Sets the input embeddings for the XLMRobertaModel.

    Args:
        self (XLMRobertaModel): The current instance of the XLMRobertaModel class.
        value: The new input embeddings to be set. This should be of type torch.Tensor.

    Returns:
        None.

    Raises:
        None.

    Note:
        The 'value' parameter should have the same dimensions as the current word_embeddings of the model.
        The input embeddings are used to represent the input tokens as vectors in the XLMRobertaModel.
        By setting new input embeddings, the model can be fine-tuned or updated with custom embeddings.

    Example:
        ```python
        >>> model = XLMRobertaModel()
        >>> embeddings = torch.tensor([[0.1, 0.2], [0.3, 0.4]])
        >>> model.set_input_embeddings(embeddings)
        ```
    """
    self.embeddings.word_embeddings = value

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaOutput

Bases: Module

XLMRobertaOutput

Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
class XLMRobertaOutput(nn.Module):
    """XLMRobertaOutput"""
    def __init__(self, config):
        """
        Initializes an instance of XLMRobertaOutput class.

        Args:
            self (object): The instance of the XLMRobertaOutput class.
            config (object):
                An object containing configuration parameters.

                - Type: Any
                - Purpose: Specifies the configuration settings for the XLMRobertaOutput instance.
                - Restrictions: Must be a valid configuration object.

        Returns:
            None.

        Raises:
            None
        """
        super().__init__()
        self.dense = nn.Linear(config.intermediate_size, config.hidden_size)
        self.LayerNorm = nn.LayerNorm([config.hidden_size], eps=config.layer_norm_eps)
        self.dropout = nn.Dropout(p=config.hidden_dropout_prob)

    def forward(self, hidden_states: mindspore.Tensor, input_tensor: mindspore.Tensor) -> mindspore.Tensor:
        '''
        This method forwards the output of the XLMRoberta model by performing a series of operations on the
        hidden states and input tensor.

        Args:
            self (XLMRobertaOutput): The instance of the XLMRobertaOutput class.
            hidden_states (mindspore.Tensor): The tensor containing the hidden states of the XLMRoberta model.
                It is expected to be a tensor of shape [batch_size, sequence_length, hidden_size].
            input_tensor (mindspore.Tensor): The input tensor to be added to the hidden states after normalization.
                It is expected to be a tensor of the same shape as hidden_states.

        Returns:
            mindspore.Tensor: The tensor representing the forwarded output of the XLMRoberta model.
                It has the same shape as the input_tensor and hidden_states.

        Raises:
            ValueError: If the shapes of hidden_states and input_tensor are not compatible for addition.
            RuntimeError: If an error occurs during the execution of the method.
        '''
        hidden_states = self.dense(hidden_states)
        hidden_states = self.dropout(hidden_states)
        hidden_states = self.LayerNorm(hidden_states + input_tensor)
        return hidden_states

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaOutput.__init__(config)

Initializes an instance of XLMRobertaOutput class.

PARAMETER DESCRIPTION
self

The instance of the XLMRobertaOutput class.

TYPE: object

config

An object containing configuration parameters.

  • Type: Any
  • Purpose: Specifies the configuration settings for the XLMRobertaOutput instance.
  • Restrictions: Must be a valid configuration object.

TYPE: object

RETURNS DESCRIPTION

None.
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
def __init__(self, config):
    """
    Initializes an instance of XLMRobertaOutput class.

    Args:
        self (object): The instance of the XLMRobertaOutput class.
        config (object):
            An object containing configuration parameters.

            - Type: Any
            - Purpose: Specifies the configuration settings for the XLMRobertaOutput instance.
            - Restrictions: Must be a valid configuration object.

    Returns:
        None.

    Raises:
        None
    """
    super().__init__()
    self.dense = nn.Linear(config.intermediate_size, config.hidden_size)
    self.LayerNorm = nn.LayerNorm([config.hidden_size], eps=config.layer_norm_eps)
    self.dropout = nn.Dropout(p=config.hidden_dropout_prob)

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaOutput.forward(hidden_states, input_tensor)

This method forwards the output of the XLMRoberta model by performing a series of operations on the hidden states and input tensor.

PARAMETER DESCRIPTION
self

The instance of the XLMRobertaOutput class.

TYPE: XLMRobertaOutput

hidden_states

The tensor containing the hidden states of the XLMRoberta model. It is expected to be a tensor of shape [batch_size, sequence_length, hidden_size].

TYPE: Tensor

input_tensor

The input tensor to be added to the hidden states after normalization. It is expected to be a tensor of the same shape as hidden_states.

TYPE: Tensor

RETURNS DESCRIPTION
Tensor

mindspore.Tensor: The tensor representing the forwarded output of the XLMRoberta model. It has the same shape as the input_tensor and hidden_states.
RAISES DESCRIPTION
ValueError

If the shapes of hidden_states and input_tensor are not compatible for addition.
RuntimeError

If an error occurs during the execution of the method.
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
def forward(self, hidden_states: mindspore.Tensor, input_tensor: mindspore.Tensor) -> mindspore.Tensor:
    '''
    This method forwards the output of the XLMRoberta model by performing a series of operations on the
    hidden states and input tensor.

    Args:
        self (XLMRobertaOutput): The instance of the XLMRobertaOutput class.
        hidden_states (mindspore.Tensor): The tensor containing the hidden states of the XLMRoberta model.
            It is expected to be a tensor of shape [batch_size, sequence_length, hidden_size].
        input_tensor (mindspore.Tensor): The input tensor to be added to the hidden states after normalization.
            It is expected to be a tensor of the same shape as hidden_states.

    Returns:
        mindspore.Tensor: The tensor representing the forwarded output of the XLMRoberta model.
            It has the same shape as the input_tensor and hidden_states.

    Raises:
        ValueError: If the shapes of hidden_states and input_tensor are not compatible for addition.
        RuntimeError: If an error occurs during the execution of the method.
    '''
    hidden_states = self.dense(hidden_states)
    hidden_states = self.dropout(hidden_states)
    hidden_states = self.LayerNorm(hidden_states + input_tensor)
    return hidden_states

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaPooler

Bases: Module

XLMRobertaPooler

Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
class XLMRobertaPooler(nn.Module):
    """XLMRobertaPooler"""
    def __init__(self, config):
        """
        Initializes an instance of the XLMRobertaPooler class.

        Args:
            self (object): The instance of the XLMRobertaPooler class.
            config (object):
                An object containing configuration parameters.

                - hidden_size (int): The size of the hidden layer.

        Returns:
            None.

        Raises:
            None.
        """
        super().__init__()
        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
        self.activation = nn.Tanh()

    def forward(self, hidden_states: mindspore.Tensor) -> mindspore.Tensor:
        """
            Constructs the pooled output tensor from the given hidden states.

            Args:
                self: An instance of the XLMRobertaPooler class.
                hidden_states (mindspore.Tensor): The input tensor of shape (batch_size, sequence_length, hidden_size)
                    containing the hidden states of the XLM-Roberta model.

            Returns:
                mindspore.Tensor: The pooled output tensor of shape (batch_size, hidden_size) representing the
                    aggregated representation of the input sequence.

            Raises:
                None.

            """
        # We "pool" the model by simply taking the hidden state corresponding
        # to the first token.
        first_token_tensor = hidden_states[:, 0]
        pooled_output = self.dense(first_token_tensor)
        pooled_output = self.activation(pooled_output)
        return pooled_output

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaPooler.__init__(config)

Initializes an instance of the XLMRobertaPooler class.

PARAMETER DESCRIPTION
self

The instance of the XLMRobertaPooler class.

TYPE: object

config

An object containing configuration parameters.

  • hidden_size (int): The size of the hidden layer.

TYPE: object

RETURNS DESCRIPTION

None.
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
def __init__(self, config):
    """
    Initializes an instance of the XLMRobertaPooler class.

    Args:
        self (object): The instance of the XLMRobertaPooler class.
        config (object):
            An object containing configuration parameters.

            - hidden_size (int): The size of the hidden layer.

    Returns:
        None.

    Raises:
        None.
    """
    super().__init__()
    self.dense = nn.Linear(config.hidden_size, config.hidden_size)
    self.activation = nn.Tanh()

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaPooler.forward(hidden_states)

Constructs the pooled output tensor from the given hidden states.

PARAMETER DESCRIPTION
self

An instance of the XLMRobertaPooler class.
hidden_states

The input tensor of shape (batch_size, sequence_length, hidden_size) containing the hidden states of the XLM-Roberta model.

TYPE: Tensor

RETURNS DESCRIPTION
Tensor

mindspore.Tensor: The pooled output tensor of shape (batch_size, hidden_size) representing the aggregated representation of the input sequence.
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
def forward(self, hidden_states: mindspore.Tensor) -> mindspore.Tensor:
    """
        Constructs the pooled output tensor from the given hidden states.

        Args:
            self: An instance of the XLMRobertaPooler class.
            hidden_states (mindspore.Tensor): The input tensor of shape (batch_size, sequence_length, hidden_size)
                containing the hidden states of the XLM-Roberta model.

        Returns:
            mindspore.Tensor: The pooled output tensor of shape (batch_size, hidden_size) representing the
                aggregated representation of the input sequence.

        Raises:
            None.

        """
    # We "pool" the model by simply taking the hidden state corresponding
    # to the first token.
    first_token_tensor = hidden_states[:, 0]
    pooled_output = self.dense(first_token_tensor)
    pooled_output = self.activation(pooled_output)
    return pooled_output

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaPreTrainedModel

Bases: PreTrainedModel

An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained models.

Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
class XLMRobertaPreTrainedModel(PreTrainedModel):
    """
    An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
    models.
    """
    config_class = XLMRobertaConfig
    base_model_prefix = "roberta"
    supports_gradient_checkpointing = False
    _no_split_modules = ["XLMRobertaEmbeddings", "XLMRobertaSelfAttention"]

    # Copied from transformers.models.bert.modeling_bert.BertPreTrainedModel._init_weights
    def _init_weights(self, cell):
        """Initialize the weights"""
        if isinstance(cell, nn.Linear):
            # Slightly different from the TF version which uses truncated_normal for initialization
            # cf https://github.com/pytorch/pytorch/pull/5617
            cell.weight.set_data(initializer(Normal(self.config.initializer_range),
                                                    cell.weight.shape, cell.weight.dtype))
            if cell.bias is not None:
                cell.bias.set_data(initializer('zeros', cell.bias.shape, cell.bias.dtype))
        elif isinstance(cell, nn.Embedding):
            weight = np.random.normal(0.0, self.config.initializer_range, cell.weight.shape)
            if cell.padding_idx:
                weight[cell.padding_idx] = 0

            cell.weight.set_data(Tensor(weight, cell.weight.dtype))
        elif isinstance(cell, nn.LayerNorm):
            cell.weight.set_data(initializer('ones', cell.weight.shape, cell.weight.dtype))
            cell.bias.set_data(initializer('zeros', cell.bias.shape, cell.bias.dtype))

    def _set_gradient_checkpointing(self, module, value=False):
        """
        Sets the gradient checkpointing attribute of the given module.

        Args:
            self: The instance of the XLMRobertaPreTrainedModel class.
            module: The module for which to set the gradient checkpointing attribute.
                Must be an instance of XLMRobertaEncoder.
            value: The value to set for the gradient checkpointing attribute. (Default: False)

        Returns:
            None.

        Raises:
            TypeError: If the module is not an instance of XLMRobertaEncoder.
        """
        if isinstance(module, XLMRobertaEncoder):
            module.gradient_checkpointing = value

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaSelfAttention

Bases: Module

XLMRobertaSelfAttention

Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
class XLMRobertaSelfAttention(nn.Module):
    """XLMRobertaSelfAttention"""
    def __init__(self, config, position_embedding_type=None):
        """
        This method initializes an instance of the XLMRobertaSelfAttention class.

        Args:
            self: The instance of the class.
            config: An object containing the configuration settings for the XLMRobertaSelfAttention.
                It should have attributes like hidden_size, num_attention_heads, embedding_size,
                attention_probs_dropout_prob, position_embedding_type, max_position_embeddings, and is_decoder.
            position_embedding_type: (optional) A string specifying the type of position embedding. Defaults to None.
                It should be one of 'absolute', 'relative_key', or 'relative_key_query'.

        Returns:
            None.

        Raises:
            ValueError: If the hidden size in the config is not a multiple of the number of attention heads,
                and the config does not have the attribute 'embedding_size'.
            AttributeError: If the config does not have the attribute 'embedding_size' when the hidden size is
                not a multiple of the number of attention heads.
        """
        super().__init__()
        if config.hidden_size % config.num_attention_heads != 0 and not hasattr(config, "embedding_size"):
            raise ValueError(
                f"The hidden size ({config.hidden_size}) is not a multiple of the number of attention "
                f"heads ({config.num_attention_heads})"
            )

        self.num_attention_heads = config.num_attention_heads
        self.attention_head_size = int(config.hidden_size / config.num_attention_heads)
        self.all_head_size = self.num_attention_heads * self.attention_head_size

        self.query = nn.Linear(config.hidden_size, self.all_head_size)
        self.key = nn.Linear(config.hidden_size, self.all_head_size)
        self.value = nn.Linear(config.hidden_size, self.all_head_size)

        self.dropout = nn.Dropout(p=config.attention_probs_dropout_prob)
        self.position_embedding_type = position_embedding_type or getattr(
            config, "position_embedding_type", "absolute"
        )
        if self.position_embedding_type in ('relative_key', 'relative_key_query'):
            self.max_position_embeddings = config.max_position_embeddings
            self.distance_embedding = nn.Embedding(2 * config.max_position_embeddings - 1, self.attention_head_size)

        self.is_decoder = config.is_decoder

    def transpose_for_scores(self, x: mindspore.Tensor) -> mindspore.Tensor:
        """transpose_for_scores"""
        new_x_shape = x.shape[:-1] + (self.num_attention_heads, self.attention_head_size)
        x = x.view(new_x_shape)
        return x.permute(0, 2, 1, 3)

    def forward(
        self,
        hidden_states: mindspore.Tensor,
        attention_mask: Optional[mindspore.Tensor] = None,
        head_mask: Optional[mindspore.Tensor] = None,
        encoder_hidden_states: Optional[mindspore.Tensor] = None,
        encoder_attention_mask: Optional[mindspore.Tensor] = None,
        past_key_value: Optional[Tuple[Tuple[mindspore.Tensor]]] = None,
        output_attentions: Optional[bool] = False,
    ) -> Tuple[mindspore.Tensor]:
        """
        Constructs the self-attention mechanism for the XLMRoberta model.

        Args:
            self: An instance of the XLMRobertaSelfAttention class.
            hidden_states (mindspore.Tensor): The input hidden states. Shape (batch_size, seq_length, hidden_size).
            attention_mask (Optional[mindspore.Tensor]): The attention mask tensor. Shape
                (batch_size, seq_length, seq_length). Defaults to None.
            head_mask (Optional[mindspore.Tensor]): The head mask tensor.
                Shape (num_attention_heads, seq_length, seq_length). Defaults to None.
            encoder_hidden_states (Optional[mindspore.Tensor]): The hidden states from the encoder.
                Shape (batch_size, seq_length, hidden_size). Defaults to None.
            encoder_attention_mask (Optional[mindspore.Tensor]): The attention mask for the encoder hidden states.
                Shape (batch_size, seq_length, seq_length). Defaults to None.
            past_key_value (Optional[Tuple[Tuple[mindspore.Tensor]]]):
                The past key-value pairs for each layer in the encoder. Defaults to None.
            output_attentions (Optional[bool]): Whether to output attention probabilities. Defaults to False.

        Returns:
            Tuple[mindspore.Tensor]: A tuple containing the context layer tensor.
                Shape (batch_size, seq_length, hidden_size).
            If output_attentions is True, the tuple also contains attention probabilities tensor.
                Shape (batch_size, num_attention_heads, seq_length, seq_length).
            If the model is a decoder, the tuple also contains the past key-value pairs.

        Raises:
            None.
        """
        mixed_query_layer = self.query(hidden_states)

        # If this is instantiated as a cross-attention module, the keys
        # and values come from an encoder; the attention mask needs to be
        # such that the encoder's padding tokens are not attended to.
        is_cross_attention = encoder_hidden_states is not None

        if is_cross_attention and past_key_value is not None:
            # reuse k,v, cross_attentions
            key_layer = past_key_value[0]
            value_layer = past_key_value[1]
            attention_mask = encoder_attention_mask
        elif is_cross_attention:
            key_layer = self.transpose_for_scores(self.key(encoder_hidden_states))
            value_layer = self.transpose_for_scores(self.value(encoder_hidden_states))
            attention_mask = encoder_attention_mask
        elif past_key_value is not None:
            key_layer = self.transpose_for_scores(self.key(hidden_states))
            value_layer = self.transpose_for_scores(self.value(hidden_states))
            key_layer = ops.cat([past_key_value[0], key_layer], axis=2)
            value_layer = ops.cat([past_key_value[1], value_layer], axis=2)
        else:
            key_layer = self.transpose_for_scores(self.key(hidden_states))
            value_layer = self.transpose_for_scores(self.value(hidden_states))

        query_layer = self.transpose_for_scores(mixed_query_layer)

        use_cache = past_key_value is not None
        if self.is_decoder:
            # if cross_attention save Tuple(mindspore.Tensor, mindspore.Tensor) of all cross attention key/value_states.
            # Further calls to cross_attention layer can then reuse all cross-attention
            # key/value_states (first "if" case)
            # if uni-directional self-attention (decoder) save Tuple(mindspore.Tensor, mindspore.Tensor) of
            # all previous decoder key/value_states. Further calls to uni-directional self-attention
            # can concat previous decoder key/value_states to current projected key/value_states (third "elif" case)
            # if encoder bi-directional self-attention `past_key_value` is always `None`
            past_key_value = (key_layer, value_layer)

        # Take the dot product between "query" and "key" to get the raw attention scores.
        attention_scores = ops.matmul(query_layer, key_layer.swapaxes(-1, -2))

        if self.position_embedding_type in ('relative_key', 'relative_key_query'):
            query_length, key_length = query_layer.shape[2], key_layer.shape[2]
            if use_cache:
                position_ids_l = mindspore.Tensor(key_length - 1, dtype=mindspore.int64).view(-1, 1)
            else:
                position_ids_l = ops.arange(query_length, dtype=mindspore.int64).view(-1, 1)
            position_ids_r = ops.arange(key_length, dtype=mindspore.int64).view(1, -1)
            distance = position_ids_l - position_ids_r

            positional_embedding = self.distance_embedding(distance + self.max_position_embeddings - 1)
            positional_embedding = positional_embedding.to(dtype=query_layer.dtype)  # fp16 compatibility

            if self.position_embedding_type == "relative_key":
                relative_position_scores = ops.einsum("bhld,lrd->bhlr", query_layer, positional_embedding)
                attention_scores = attention_scores + relative_position_scores
            elif self.position_embedding_type == "relative_key_query":
                relative_position_scores_query = ops.einsum("bhld,lrd->bhlr", query_layer, positional_embedding)
                relative_position_scores_key = ops.einsum("bhrd,lrd->bhlr", key_layer, positional_embedding)
                attention_scores = attention_scores + relative_position_scores_query + relative_position_scores_key

        attention_scores = attention_scores / math.sqrt(self.attention_head_size)
        if attention_mask is not None:
            # Apply the attention mask is (precomputed for all layers in XLMRobertaModel forward() function)
            attention_scores = attention_scores + attention_mask

        # Normalize the attention scores to probabilities.
        attention_probs = ops.softmax(attention_scores, axis=-1)

        # This is actually dropping out entire tokens to attend to, which might
        # seem a bit unusual, but is taken from the original Transformer paper.
        attention_probs = self.dropout(attention_probs)

        # Mask heads if we want to
        if head_mask is not None:
            attention_probs = attention_probs * head_mask

        context_layer = ops.matmul(attention_probs, value_layer)

        context_layer = context_layer.transpose(0, 2, 1, 3)
        new_context_layer_shape = context_layer.shape[:-2] + (self.all_head_size,)
        context_layer = context_layer.view(new_context_layer_shape)

        outputs = (context_layer, attention_probs) if output_attentions else (context_layer,)

        if self.is_decoder:
            outputs = outputs + (past_key_value,)
        return outputs

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaSelfAttention.__init__(config, position_embedding_type=None)

This method initializes an instance of the XLMRobertaSelfAttention class.

PARAMETER DESCRIPTION
self

The instance of the class.
config

An object containing the configuration settings for the XLMRobertaSelfAttention. It should have attributes like hidden_size, num_attention_heads, embedding_size, attention_probs_dropout_prob, position_embedding_type, max_position_embeddings, and is_decoder.
position_embedding_type

(optional) A string specifying the type of position embedding. Defaults to None. It should be one of 'absolute', 'relative_key', or 'relative_key_query'.

DEFAULT: None

RETURNS DESCRIPTION

None.
RAISES DESCRIPTION
ValueError

If the hidden size in the config is not a multiple of the number of attention heads, and the config does not have the attribute 'embedding_size'.
AttributeError

If the config does not have the attribute 'embedding_size' when the hidden size is not a multiple of the number of attention heads.
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
def __init__(self, config, position_embedding_type=None):
    """
    This method initializes an instance of the XLMRobertaSelfAttention class.

    Args:
        self: The instance of the class.
        config: An object containing the configuration settings for the XLMRobertaSelfAttention.
            It should have attributes like hidden_size, num_attention_heads, embedding_size,
            attention_probs_dropout_prob, position_embedding_type, max_position_embeddings, and is_decoder.
        position_embedding_type: (optional) A string specifying the type of position embedding. Defaults to None.
            It should be one of 'absolute', 'relative_key', or 'relative_key_query'.

    Returns:
        None.

    Raises:
        ValueError: If the hidden size in the config is not a multiple of the number of attention heads,
            and the config does not have the attribute 'embedding_size'.
        AttributeError: If the config does not have the attribute 'embedding_size' when the hidden size is
            not a multiple of the number of attention heads.
    """
    super().__init__()
    if config.hidden_size % config.num_attention_heads != 0 and not hasattr(config, "embedding_size"):
        raise ValueError(
            f"The hidden size ({config.hidden_size}) is not a multiple of the number of attention "
            f"heads ({config.num_attention_heads})"
        )

    self.num_attention_heads = config.num_attention_heads
    self.attention_head_size = int(config.hidden_size / config.num_attention_heads)
    self.all_head_size = self.num_attention_heads * self.attention_head_size

    self.query = nn.Linear(config.hidden_size, self.all_head_size)
    self.key = nn.Linear(config.hidden_size, self.all_head_size)
    self.value = nn.Linear(config.hidden_size, self.all_head_size)

    self.dropout = nn.Dropout(p=config.attention_probs_dropout_prob)
    self.position_embedding_type = position_embedding_type or getattr(
        config, "position_embedding_type", "absolute"
    )
    if self.position_embedding_type in ('relative_key', 'relative_key_query'):
        self.max_position_embeddings = config.max_position_embeddings
        self.distance_embedding = nn.Embedding(2 * config.max_position_embeddings - 1, self.attention_head_size)

    self.is_decoder = config.is_decoder

mindnlp.transformers.models.xlm_roberta.modeling_xlm_roberta.XLMRobertaSelfAttention.forward(hidden_states, attention_mask=None, head_mask=None, encoder_hidden_states=None, encoder_attention_mask=None, past_key_value=None, output_attentions=False)

Constructs the self-attention mechanism for the XLMRoberta model.

PARAMETER DESCRIPTION
self

An instance of the XLMRobertaSelfAttention class.
hidden_states

The input hidden states. Shape (batch_size, seq_length, hidden_size).

TYPE: Tensor

attention_mask

The attention mask tensor. Shape (batch_size, seq_length, seq_length). Defaults to None.

TYPE: Optional[Tensor] DEFAULT: None

head_mask

The head mask tensor. Shape (num_attention_heads, seq_length, seq_length). Defaults to None.

TYPE: Optional[Tensor] DEFAULT: None

encoder_hidden_states

The hidden states from the encoder. Shape (batch_size, seq_length, hidden_size). Defaults to None.

TYPE: Optional[Tensor] DEFAULT: None

encoder_attention_mask

The attention mask for the encoder hidden states. Shape (batch_size, seq_length, seq_length). Defaults to None.

TYPE: Optional[Tensor] DEFAULT: None

past_key_value

The past key-value pairs for each layer in the encoder. Defaults to None.

TYPE: Optional[Tuple[Tuple[Tensor]]] DEFAULT: None

output_attentions

Whether to output attention probabilities. Defaults to False.

TYPE: Optional[bool] DEFAULT: False

RETURNS DESCRIPTION
Tuple[Tensor]

Tuple[mindspore.Tensor]: A tuple containing the context layer tensor. Shape (batch_size, seq_length, hidden_size).
Tuple[Tensor]

If output_attentions is True, the tuple also contains attention probabilities tensor. Shape (batch_size, num_attention_heads, seq_length, seq_length).
Tuple[Tensor]

If the model is a decoder, the tuple also contains the past key-value pairs.
Source code in mindnlp/transformers/models/xlm_roberta/modeling_xlm_roberta.py 
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
def forward(
    self,
    hidden_states: mindspore.Tensor,
    attention_mask: Optional[mindspore.Tensor] = None,
    head_mask: Optional[mindspore.Tensor] = None,
    encoder_hidden_states: Optional[mindspore.Tensor] = None,
    encoder_attention_mask: Optional[mindspore.Tensor] = None,
    past_key_value: Optional[Tuple[Tuple[mindspore.Tensor]]] = None,
    output_attentions: Optional[bool] = False,
) -> Tuple[mindspore.Tensor]:
    """
    Constructs the self-attention mechanism for the XLMRoberta model.

    Args:
        self: An instance of the XLMRobertaSelfAttention class.
        hidden_states (mindspore.Tensor): The input hidden states. Shape (batch_size, seq_length, hidden_size).
        attention_mask (Optional[mindspore.Tensor]): The attention mask tensor. Shape
            (batch_size, seq_length, seq_length). Defaults to None.
        head_mask (Optional[mindspore.Tensor]): The head mask tensor.
            Shape (num_attention_heads, seq_length, seq_length). Defaults to None.
        encoder_hidden_states (Optional[mindspore.Tensor]): The hidden states from the encoder.
            Shape (batch_size, seq_length, hidden_size). Defaults to None.
        encoder_attention_mask (Optional[mindspore.Tensor]): The attention mask for the encoder hidden states.
            Shape (batch_size, seq_length, seq_length). Defaults to None.
        past_key_value (Optional[Tuple[Tuple[mindspore.Tensor]]]):
            The past key-value pairs for each layer in the encoder. Defaults to None.
        output_attentions (Optional[bool]): Whether to output attention probabilities. Defaults to False.

    Returns:
        Tuple[mindspore.Tensor]: A tuple containing the context layer tensor.
            Shape (batch_size, seq_length, hidden_size).
        If output_attentions is True, the tuple also contains attention probabilities tensor.
            Shape (batch_size, num_attention_heads, seq_length, seq_length).
        If the model is a decoder, the tuple also contains the past key-value pairs.

    Raises:
        None.
    """
    mixed_query_layer = self.query(hidden_states)

    # If this is instantiated as a cross-attention module, the keys
    # and values come from an encoder; the attention mask needs to be
    # such that the encoder's padding tokens are not attended to.
    is_cross_attention = encoder_hidden_states is not None

    if is_cross_attention and past_key_value is not None:
        # reuse k,v, cross_attentions
        key_layer = past_key_value[0]
        value_layer = past_key_value[1]
        attention_mask = encoder_attention_mask
    elif is_cross_attention:
        key_layer = self.transpose_for_scores(self.key(encoder_hidden_states))
        value_layer = self.transpose_for_scores(self.value(encoder_hidden_states))
        attention_mask = encoder_attention_mask
    elif past_key_value is not None:
        key_layer = self.transpose_for_scores(self.key(hidden_states))
        value_layer = self.transpose_for_scores(self.value(hidden_states))
        key_layer = ops.cat([past_key_value[0], key_layer], axis=2)
        value_layer = ops.cat([past_key_value[1], value_layer], axis=2)
    else:
        key_layer = self.transpose_for_scores(self.key(hidden_states))
        value_layer = self.transpose_for_scores(self.value(hidden_states))

    query_layer = self.transpose_for_scores(mixed_query_layer)

    use_cache = past_key_value is not None
    if self.is_decoder:
        # if cross_attention save Tuple(mindspore.Tensor, mindspore.Tensor) of all cross attention key/value_states.
        # Further calls to cross_attention layer can then reuse all cross-attention
        # key/value_states (first "if" case)
        # if uni-directional self-attention (decoder) save Tuple(mindspore.Tensor, mindspore.Tensor) of
        # all previous decoder key/value_states. Further calls to uni-directional self-attention
        # can concat previous decoder key/value_states to current projected key/value_states (third "elif" case)
        # if encoder bi-directional self-attention `past_key_value` is always `None`
        past_key_value = (key_layer, value_layer)

    # Take the dot product between "query" and "key" to get the raw attention scores.
    attention_scores = ops.matmul(query_layer, key_layer.swapaxes(-1, -2))

    if self.position_embedding_type in ('relative_key', 'relative_key_query'):
        query_length, key_length = query_layer.shape[2], key_layer.shape[2]
        if use_cache:
            position_ids_l = mindspore.Tensor(key_length - 1, dtype=mindspore.int64).view(-1, 1)
        else:
            position_ids_l = ops.arange(query_length, dtype=mindspore.int64).view(-1, 1)
        position_ids_r = ops.arange(key_length, dtype=mindspore.int64).view(1, -1)
        distance = position_ids_l - position_ids_r

        positional_embedding = self.distance_embedding(distance + self.max_position_embeddings - 1)
        positional_embedding = positional_embedding.to(dtype=query_layer.dtype)  # fp16 compatibility

        if self.position_embedding_type == "relative_key":
            relative_position_scores = ops.einsum("bhld,lrd->bhlr", query_layer, positional_embedding)
            attention_scores = attention_scores + relative_position_scores
        elif self.position_embedding_type == "relative_key_query":
            relative_position_scores_query = ops.einsum("bhld,lrd->bhlr", query_layer, positional_embedding)
            relative_position_scores_key = ops.einsum("bhrd,lrd->bhlr", key_layer, positional_embedding)
            attention_scores = attention_scores + relative_position_scores_query + relative_position_scores_key

    attention_scores = attention_scores / math.sqrt(self.attention_head_size)
    if attention_mask is not None:
        # Apply the attention mask is (precomputed for all layers in XLMRobertaModel forward() function)
        attention_scores = attention_scores + attention_mask

    # Normalize the attention scores to probabilities.
    attention_probs = ops.softmax(attention_scores, axis=-1)

    # This is actually dropping out entire tokens to attend to, which might
    # seem a bit unusual, but is taken from the original Transformer paper.
    attention_probs = self.dropout(attention_probs)

    # Mask heads if we want to
    if head_mask is not None:
        attention_probs = attention_probs * head_mask

    context_layer = ops.matmul(attention_probs