Deberta V3 Large Lemon Spell 5k

🚀 语法错误纠正模型

本模型是一个基于microsoft/deberta-v3-large微调的语法错误纠正（GEC）系统，能够检测并纠正英文文本中的语法错误。它聚焦于常见语法错误，如动词时态、名词词形变化、形容词用法等，对语言学习者或需要提高语法准确性的应用程序非常有用。

🚀 快速开始

以下是使用该模型的示例代码：

from dataclasses import dataclass
from typing import Optional, Tuple

import torch
from torch import nn
from torch.nn import CrossEntropyLoss
from transformers import AutoConfig, AutoTokenizer
from transformers.file_utils import ModelOutput
from transformers.models.deberta_v2.modeling_deberta_v2 import (
    DebertaV2Model,
    DebertaV2PreTrainedModel,
)


@dataclass
class XGECToROutput(ModelOutput):
    """
    Output type of `XGECToRForTokenClassification.forward()`.
    loss (`torch.FloatTensor`, optional)
    logits_correction (`torch.FloatTensor`) : The correction logits for each token.
    logits_detection (`torch.FloatTensor`) : The detection logits for each token.
    hidden_states (`Tuple[torch.FloatTensor]`, optional)
    attentions (`Tuple[torch.FloatTensor]`, optional)
    """

    loss: Optional[torch.FloatTensor] = None
    logits_correction: torch.FloatTensor = None
    logits_detection: torch.FloatTensor = None
    hidden_states: Optional[Tuple[torch.FloatTensor]] = None
    attentions: Optional[Tuple[torch.FloatTensor]] = None


class XGECToRDebertaV3(DebertaV2PreTrainedModel):
    """
    This class overrides the GECToR model to include an error detection head in addition to the token classification head.
    """

    _keys_to_ignore_on_load_unexpected = [r"pooler"]
    _keys_to_ignore_on_load_missing = [r"position_ids"]

    def __init__(self, config):
        super().__init__(config)
        self.num_labels = config.num_labels
        self.unk_tag_idx = config.label2id.get("@@UNKNOWN@@", None)

        self.deberta = DebertaV2Model(config)

        self.classifier = nn.Linear(config.hidden_size, config.num_labels)

        if self.unk_tag_idx is not None:
            self.error_detector = nn.Linear(config.hidden_size, 3)
        else:
            self.error_detector = nn.Linear(config.hidden_size, 2)

    def forward(
        self,
        input_ids=None,
        attention_mask=None,
        token_type_ids=None,
        position_ids=None,
        inputs_embeds=None,
        labels=None,
        output_attentions=None,
        output_hidden_states=None,
        return_dict=None,
    ):
        r"""
        labels (`torch.LongTensor` 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.deberta(
            input_ids,
            attention_mask=attention_mask,
            token_type_ids=token_type_ids,
            position_ids=position_ids,
            inputs_embeds=inputs_embeds,
            output_attentions=output_attentions,
            output_hidden_states=output_hidden_states,
            return_dict=return_dict,
        )

        sequence_output = outputs[0]

        logits_correction = self.classifier(sequence_output)
        logits_detection = self.error_detector(sequence_output)

        loss = None
        if labels is not None:
            loss_fct = CrossEntropyLoss()
            loss = loss_fct(
                logits_correction.view(-1, self.num_labels), labels.view(-1)
            )

            labels_detection = torch.ones_like(labels)
            labels_detection[labels == 0] = 0
            labels_detection[labels == -100] = -100  # ignore padding
            if self.unk_tag_idx is not None:
                labels_detection[labels == self.unk_tag_idx] = 2
                loss_detection = loss_fct(
                    logits_detection.view(-1, 3), labels_detection.view(-1)
                )
            else:
                loss_detection = loss_fct(
                    logits_detection.view(-1, 2), labels_detection.view(-1)
                )

            loss += loss_detection

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

        return XGECToROutput(
            loss=loss,
            logits_correction=logits_correction,
            logits_detection=logits_detection,
            hidden_states=outputs.hidden_states,
            attentions=outputs.attentions,
        )

    def get_input_embeddings(self):
        return self.deberta.get_input_embeddings()

    def set_input_embeddings(self, value):
        self.deberta.set_input_embeddings(value)


config = AutoConfig.from_pretrained("manred1997/deberta-v3-large-lemon-spell_5k")
tokenizer = AutoTokenizer.from_pretrained("manred1997/deberta-v3-large-lemon-spell_5k")
model = XGECToRDeberta.from_pretrained(
    "manred1997/deberta-v3-large-lemon-spell_5k", config=config
)

✨ 主要特性

• 精准纠错：能够准确检测并纠正英文文本中的常见语法错误。
• 可微调性：可以针对特定领域（如学术写作、商务沟通等）进行微调，以提高特定语境下的纠错精度。

📚 详细文档

模型详情

模型描述

本模型是一个语法错误纠正（GEC）系统，基于microsoft/deberta-v3-large模型进行微调。它旨在检测并纠正英文文本中的语法错误，专注于常见的语法错误类型，如动词时态、名词词形变化、形容词用法等。该模型对于语言学习者或需要提高语法准确性的应用程序特别有用。

用途

直接使用

该模型可直接用于检测和纠正英文文本中的语法错误，非常适合集成到写作助手、教育软件或校对工具中。

下游使用

可以针对特定领域（如学术写作、商务沟通或非正式文本纠正）对模型进行微调，以确保在特定语境下对语法错误的高精度纠正。

不适用场景

本模型不适用于非英文文本、非语法纠正（如风格、语气或逻辑），或检测超出基本语法结构的复杂错误。

偏差、风险和局限性

该模型在通用英文语料库上进行训练，对于非标准方言（如口语）或特定领域的行话可能表现不佳。由于训练数据的局限性，在这些语境中应用时，可能会引入或忽略一些错误。

建议

尽管该模型在一般情况下表现出色，但用户应手动审查纠正结果，特别是在专业或创造性语境中，因为这些语境中的语法规则可能更加灵活。

🔧 技术细节

训练详情

训练数据

模型的训练分为三个阶段，每个阶段需要特定的数据集。以下是每个阶段使用的数据描述：

评估

测试数据、因素和指标

测试数据

模型在W&I + Locness测试集上进行了测试，这是语法错误纠正的标准基准。

指标

主要使用的评估指标是F0.5，用于衡量模型正确识别和修复语法错误的能力。

结果

F0.5 = 74.61