【无标题】

已于 2023-06-20 20:29:47 修改
阅读量256 收藏
点赞数
文章标签： 深度学习 人工智能
于 2023-06-09 02:48:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dsbss/article/details/131119070
版权
本文介绍了使用ERNIE、ALBERT、RoBERTa、XLNet、ELECTRA和SpanBERT等预训练模型进行中文文本分类的方法，包括加载tokenizer和模型，以及训练和评估过程。这些模型在不同数据集上的表现各异，适用于15类文本分类任务。
摘要由CSDN通过智能技术生成

【ERNIE】分类15类大多数是中文的文本

from transformers import AutoTokenizer, AutoModelForSequenceClassification

# 加载 ERNIE tokenizer
tokenizer = AutoTokenizer.from_pretrained("nghuyong/ernie-1.0")

# 加载 ERNIE 预训练模型，用于分类任务
model = AutoModelForSequenceClassification.from_pretrained("nghuyong/ernie-1.0", num_labels=15)

# 对输入文本进行编码
text = "这是一段待分类的中文文本。"
encoded_input = tokenizer(text, truncation=True, padding=True, return_tensors='pt')

# 获取模型输出
output = model(**encoded_input)

这段代码使用 AutoTokenizer 类从 "nghuyong/ernie-1.0" checkpoint 加载 tokenizer，并使用 AutoModelForSequenceClassification 类从相同的 checkpoint 加载预训练模型。在这个例子中，该模型用于中文文本分类任务，因此 num_labels 参数被设置为 15，这是数据集中的类别数目。

# 结果：ERNIE分类15类大多数是中文的文本——max=64

------------Epoch: 0 ----------------
epoch: 0, iter_num: 100, loss: 1.7696, 15.38%
epoch: 0, iter_num: 200, loss: 0.6329, 30.77%
epoch: 0, iter_num: 300, loss: 0.5543, 46.15%
epoch: 0, iter_num: 400, loss: 1.2803, 61.54%
epoch: 0, iter_num: 500, loss: 0.4909, 76.92%
epoch: 0, iter_num: 600, loss: 0.7790, 92.31%
Epoch: 0, Average training loss: 0.9317
Accuracy: 0.8409
Average testing loss: 0.5869
-------------------------------
------------Epoch: 1 ----------------
epoch: 1, iter_num: 100, loss: 0.4217, 15.38%
epoch: 1, iter_num: 200, loss: 0.1333, 30.77%
epoch: 1, iter_num: 300, loss: 0.5391, 46.15%
epoch: 1, iter_num: 400, loss: 0.4612, 61.54%
epoch: 1, iter_num: 500, loss: 0.3900, 76.92%
epoch: 1, iter_num: 600, loss: 0.4132, 92.31%
Epoch: 1, Average training loss: 0.4501
Accuracy: 0.8466
Average testing loss: 0.5791
-------------------------------
------------Epoch: 2 ----------------
epoch: 2, iter_num: 100, loss: 0.6343, 15.38%
epoch: 2, iter_num: 200, loss: 0.4136, 30.77%
epoch: 2, iter_num: 300, loss: 0.2595, 46.15%
epoch: 2, iter_num: 400, loss: 0.4415, 61.54%
epoch: 2, iter_num: 500, loss: 0.1030, 76.92%
epoch: 2, iter_num: 600, loss: 0.0143, 92.31%
Epoch: 2, Average training loss: 0.3240
Accuracy: 0.8443
Average testing loss: 0.6346
-------------------------------
------------Epoch: 3 ----------------
epoch: 3, iter_num: 100, loss: 0.3799, 15.38%
epoch: 3, iter_num: 200, loss: 0.6112, 30.77%
epoch: 3, iter_num: 300, loss: 0.1612, 46.15%
epoch: 3, iter_num: 400, loss: 0.1312, 61.54%
epoch: 3, iter_num: 500, loss: 0.4110, 76.92%
epoch: 3, iter_num: 600, loss: 0.0074, 92.31%
Epoch: 3, Average training loss: 0.2366
Accuracy: 0.8501
Average testing loss: 0.7379
-------------------------------
------------Epoch: 4 ----------------
epoch: 4, iter_num: 100, loss: 0.1996, 15.38%
epoch: 4, iter_num: 200, loss: 0.3158, 30.77%
epoch: 4, iter_num: 300, loss: 0.0271, 46.15%
epoch: 4, iter_num: 400, loss: 0.0166, 61.54%
epoch: 4, iter_num: 500, loss: 0.2053, 76.92%
epoch: 4, iter_num: 600, loss: 0.4321, 92.31%
Epoch: 4, Average training loss: 0.1704
Accuracy: 0.8459
Average testing loss: 0.7492
-------------------------------

分类15类的中文预训练模型和tokenizer

from transformers import AutoTokenizer, AutoModelForSequenceClassification

# 加载分类15类 tokenizer
tokenizer = AutoTokenizer.from_pretrained("bert-base-chinese")

# 加载分类15类预训练模型，用于分类任务
model = AutoModelForSequenceClassification.from_pretrained("ckiplab/bert-base-chinese-15cls", num_labels=15)

 这段代码使用 AutoTokenizer 类从 "bert-base-chinese" checkpoint 加载 tokenizer，并使用 AutoModelForSequenceClassification 类从 "ckiplab/bert-base-chinese-15cls" checkpoint 加载分类15类预训练模型。在这个例子中，该模型用于中文文本分类任务，因此 num_labels 参数被设置为 15，这是数据集中的类别数目。

【ALBERT】分类15类文本

  1. 准备好文本分类的数据集，将其分成训练集、验证集和测试集，并进行标注。

  2. 下载ALBERT的预训练模型权重，通常来自于Hugging Face提供的Transformers库，或Google Research发布的官方源码。

  3. 使用相应的深度学习框架，例如PyTorch或TensorFlow，加载ALBERT模型，并根据需要对模型进行微调或者冻结预训练模型的权重进行fine-tuning。

  4. 对训练集进行训练，使用验证集进行模型调优，最终在测试集上进行模型评估。

以下是一个ALBERT+PyTorch的分类模型示例代码，用于15类文本分类

import torch
from transformers import AlbertTokenizer, AlbertForSequenceClassification

# 加载预训练模型和tokenizer
tokenizer = AlbertTokenizer.from_pretrained('albert-base-v2')
model = AlbertForSequenceClassification.from_pretrained('albert-base-v2', num_labels=15)

# 准备数据集
train_texts = [...] # 训练集文本
train_labels = [...] # 训练集标签
val_texts = [...] # 验证集文本
val_labels = [...] # 验证集标签
test_texts = [...] # 测试集文本
test_labels = [...] # 测试集标签

def encode_text(texts):
    return tokenizer.batch_encode_plus(texts, padding=True, truncation=True, return_tensors='pt')

train_encodings = encode_text(train_texts)
val_encodings = encode_text(val_texts)
test_encodings = encode_text(test_texts)

# 将训练集和验证集的标签作为Tensor传入
train_labels = torch.tensor(train_labels)
val_labels = torch.tensor(val_labels)

# 将预处理好的数据输入模型中进行微调
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-5)
train_dataset = torch.utils.data.TensorDataset(train_encodings['input_ids'], train_encodings['attention_mask'], train_labels)
val_dataset = torch.utils.data.TensorDataset(val_encodings['input_ids'], val_encodings['attention_mask'], val_labels)

# 定义训练函数
def train_epoch(model, dataloader, optimizer):
    model.train()
    for batch in dataloader:
        optimizer.zero_grad()
        input_ids, attention_mask, labels = batch
        outputs = model(input_ids, attention_mask=attention_mask, labels=labels)
        loss = outputs[0]
        loss.backward()
        optimizer.step()
    return loss.item()

# 开始训练
train_dataloader = torch.utils.data.DataLoader(train_dataset, batch_size=16, shuffle=True)
val_dataloader = torch.utils.data.DataLoader(val_dataset, batch_size=16, shuffle=False)

for epoch in range(3):
    train_loss = train_epoch(model, train_dataloader, optimizer)
    print(f'training loss: {train_loss}')

    # 在验证集上评估模型
    model.eval()
    with torch.no_grad():
        val_preds = []
        for batch in val_dataloader:
            input_ids, attention_mask, labels = batch
            outputs = model(input_ids, attention_mask=attention_mask)
            val_preds += outputs[0].argmax(axis=-1).tolist()
    acc = sum([1 if p == l else 0 for p, l in zip(val_preds, val_labels)]) / len(val_labels)
    print(f'validation accuracy: {acc}')

# 在测试集上进行测试
test_dataset = torch.utils.data.TensorDataset(test_encodings['input_ids'], test_encodings['attention_mask'])
test_dataloader = torch.utils.data.DataLoader(test_dataset, batch_size=16, shuffle=False)

model.eval()
with torch.no_grad():
    test_preds = []
    for batch in test_dataloader:
        input_ids, attention_mask = batch
        outputs = model(input_ids, attention_mask=attention_mask)
        test_preds += outputs[0].argmax(axis=-1).tolist()
acc = sum([1 if p == l else 0 for p, l in zip(test_preds, test_labels)]) / len(test_labels)
print(f'test accuracy: {acc}')

其中，ALBERT的预训练模型可以通过AlbertTokenizer.from_pretrained()和AlbertForSequenceClassification.from_pretrained()方法直接加载，并在调用forward()方法时传递文本的input_ids和attention_mask。在实际应用中，常常需要根据具体情况进行微调，例如调整batch_size、学习率、优化器等参数，或者在模型中添加额外的层和损失函数，以获取更好的效果。

ALBERT分类15类中文文本的预训练模型和tokenizer

  1. 首先，确保您已经安装了huggingface transformers这个Python库。

  2. 接下来，从Hugging Face的模型存储库中获取ALBERT预训练模型。例如，您可以选择ALBERT-base或ALBERT-large模型。您可以使用下面的代码之一：

from transformers import AlbertTokenizer, AlbertForSequenceClassification

# 加载预训练ALBERT-base模型
tokenizer = AlbertTokenizer.from_pretrained('voidful/albert_chinese_base')
model = AlbertForSequenceClassification.from_pretrained('voidful/albert_chinese_base', num_labels=15)

# 加载预训练ALBERT-large模型
tokenizer = AlbertTokenizer.from_pretrained('voidful/albert_chinese_large')
model = AlbertForSequenceClassification.from_pretrained('voidful/albert_chinese_large', num_labels=15)

【RoBERTa】预训练模型和tokenizer

from transformers import RobertaTokenizer, RobertaForSequenceClassification

# 加载RoBERTa tokenizer
tokenizer = RobertaTokenizer.from_pretrained('hfl/chinese-roberta-wwm-ext')

# 加载RoBERTa分类模型
model = RobertaForSequenceClassification.from_pretrained('hfl/chinese-roberta-wwm-ext', num_labels=15)

#————————————————————————————————————————————————————————————————————————————————

from transformers import RobertaTokenizerFast, RobertaForSequenceClassification

# Load the RoBERTa tokenizer
tokenizer = RobertaTokenizerFast.from_pretrained('hfl/chinese-roberta-wwm-ext')

# Load the pre-trained RoBERTa model for sequence classification
model = RobertaForSequenceClassification.from_pretrained('hfl/chinese-roberta-wwm-ext', num_labels=15)

这个代码示例使用’Hugging Face’ Transformers库中的RobertaTokenizer和RobertaForSequenceClassification类来加载预训练的RoBERTa模型和tokenizer。from_pretrained方法用于从预训练模型加载tokenizer和模型参数。

请注意， RobertaForSequenceClassification需要指定num_labels参数，以指定文本分类的数量。在这个例子中，共有15个分类。您可以根据您的分类任务修改此数字。

同时，基于该预训练模型训练的分类任务使用了中文文本，因此所加载的预训练模型也应为中文预训练模型。在这个例子中，使用的是’chinese-roberta-wwm-ext’模型。如果需要使用其他预训练模型，可以在’Hugging Face’ transformers文档中查找可用的模型列表。

RoBERTa（中文版）：RoBERTa 是由 Facebook AI 团队提出的 BERT 变种，其训练过程使用了更多的数据和更长的训练时间。RoBERTa 的中文版也已经发布，并取得了比同等条件下 BERT 更好的效果。你可以通过 Hugging Face 的 Transformers 库来使用 RoBERTa。

【XLNet】分类15类的中文给出如何加载预训练模型和tokenizer

# 导入必要的库
import torch
from transformers import XLNetTokenizer, XLNetForSequenceClassification

# 定义分类类别数
num_labels = 15

# 加载预训练模型和tokenizer
model_name = 'hfl/chinese-xlnet-base'
tokenizer = XLNetTokenizer.from_pretrained(model_name)
model = XLNetForSequenceClassification.from_pretrained(model_name, num_labels=num_labels)

在上面的代码中，我们首先定义了分类类别数 num_labels，然后通过 XLNetForSequenceClassification 类来加载预训练模型，设置 num_labels 参数为分类类别数。

接着使用 XLNetTokenizer 类来加载对应的tokenizer，然后对样本进行编码，生成输入张量，最后将输入张量传入XLNetForSequenceClassification 模型中获取分类结果。

需要注意的是，本例中我们使用了padding和截断技术来规范输入的文本长度，使之适配模型的输入要求，这里我们将长度限制为64。实际上，长度的限制需要根据具体的应用场景和任务来进行调整。

XLNet：XLNet 是 CMU 和 Google 提出的第一个非自回归的预训练模型。它采用 Transformer-XL 的结构来解决 BERT 中存在的顺序建模的限制，从而更好地捕捉文本中的上下文信息，对中文文本分类也大有帮助。

结果：

# XLNet
#                               ——max=64
# Epoch: 4, Average training loss: 0.1858
# Accuracy: 0.8409

------------Epoch: 0 ----------------
epoch: 0, iter_num: 100, loss: 1.0723, 15.38%
epoch: 0, iter_num: 200, loss: 0.9870, 30.77%
epoch: 0, iter_num: 300, loss: 0.2781, 46.15%
epoch: 0, iter_num: 400, loss: 0.5312, 61.54%
epoch: 0, iter_num: 500, loss: 0.2781, 76.92%
epoch: 0, iter_num: 600, loss: 0.5329, 92.31%
Epoch: 0, Average training loss: 0.9603
Accuracy: 0.8183
Average testing loss: 0.6233
-------------------------------
------------Epoch: 1 ----------------
epoch: 1, iter_num: 100, loss: 0.9092, 15.38%
epoch: 1, iter_num: 200, loss: 0.4809, 30.77%
epoch: 1, iter_num: 300, loss: 0.2143, 46.15%
epoch: 1, iter_num: 400, loss: 0.7193, 61.54%
epoch: 1, iter_num: 500, loss: 0.2858, 76.92%
epoch: 1, iter_num: 600, loss: 0.3786, 92.31%
Epoch: 1, Average training loss: 0.5122
Accuracy: 0.8290
Average testing loss: 0.6355
-------------------------------
------------Epoch: 2 ----------------
epoch: 2, iter_num: 100, loss: 0.2993, 15.38%
epoch: 2, iter_num: 200, loss: 0.4890, 30.77%
epoch: 2, iter_num: 300, loss: 0.2096, 46.15%
epoch: 2, iter_num: 400, loss: 0.2015, 61.54%
epoch: 2, iter_num: 500, loss: 0.4490, 76.92%
epoch: 2, iter_num: 600, loss: 0.2591, 92.31%
Epoch: 2, Average training loss: 0.3701
Accuracy: 0.8336
Average testing loss: 0.6460
-------------------------------
------------Epoch: 3 ----------------
epoch: 3, iter_num: 100, loss: 0.0596, 15.38%
epoch: 3, iter_num: 200, loss: 0.2204, 30.77%
epoch: 3, iter_num: 300, loss: 0.0602, 46.15%
epoch: 3, iter_num: 400, loss: 0.2729, 61.54%
epoch: 3, iter_num: 500, loss: 0.2173, 76.92%
epoch: 3, iter_num: 600, loss: 0.6965, 92.31%
Epoch: 3, Average training loss: 0.2579
Accuracy: 0.8401
Average testing loss: 0.7422
-------------------------------
------------Epoch: 4 ----------------
epoch: 4, iter_num: 100, loss: 0.4096, 15.38%
epoch: 4, iter_num: 200, loss: 0.4123, 30.77%
epoch: 4, iter_num: 300, loss: 0.3764, 46.15%
epoch: 4, iter_num: 400, loss: 0.7553, 61.54%
epoch: 4, iter_num: 500, loss: 0.1620, 76.92%
epoch: 4, iter_num: 600, loss: 0.9384, 92.31%
Epoch: 4, Average training loss: 0.1858
Accuracy: 0.8409
Average testing loss: 0.8066
-------------------------------
# max_length=64
------------Epoch: 0 ----------------
epoch: 0, iter_num: 100, loss: 1.5357, 15.38%
epoch: 0, iter_num: 200, loss: 0.9866, 30.77%
epoch: 0, iter_num: 300, loss: 1.2628, 46.15%
epoch: 0, iter_num: 400, loss: 0.6299, 61.54%
epoch: 0, iter_num: 500, loss: 1.0743, 76.92%
epoch: 0, iter_num: 600, loss: 0.4764, 92.31%
Epoch: 0, Average training loss: 0.9521
Accuracy: 0.8213
Average testing loss: 0.6333
-------------------------------
------------Epoch: 1 ----------------
epoch: 1, iter_num: 100, loss: 0.2546, 15.38%
epoch: 1, iter_num: 200, loss: 1.0636, 30.77%
epoch: 1, iter_num: 300, loss: 0.9060, 46.15%
epoch: 1, iter_num: 400, loss: 0.2629, 61.54%
epoch: 1, iter_num: 500, loss: 0.5542, 76.92%
epoch: 1, iter_num: 600, loss: 0.8182, 92.31%
Epoch: 1, Average training loss: 0.5034
Accuracy: 0.8282
Average testing loss: 0.6348
-------------------------------
------------Epoch: 2 ----------------
epoch: 2, iter_num: 100, loss: 0.3969, 15.38%
epoch: 2, iter_num: 200, loss: 0.4862, 30.77%
epoch: 2, iter_num: 300, loss: 0.1850, 46.15%
epoch: 2, iter_num: 400, loss: 0.0726, 61.54%
epoch: 2, iter_num: 500, loss: 0.0423, 76.92%
epoch: 2, iter_num: 600, loss: 0.3782, 92.31%
Epoch: 2, Average training loss: 0.3632
Accuracy: 0.8351
Average testing loss: 0.6708
-------------------------------
------------Epoch: 3 ----------------
epoch: 3, iter_num: 100, loss: 0.2537, 15.38%
epoch: 3, iter_num: 200, loss: 0.0146, 30.77%
epoch: 3, iter_num: 300, loss: 0.0781, 46.15%
epoch: 3, iter_num: 400, loss: 0.0059, 61.54%
epoch: 3, iter_num: 500, loss: 0.4188, 76.92%
epoch: 3, iter_num: 600, loss: 0.2212, 92.31%
Epoch: 3, Average training loss: 0.2607
Accuracy: 0.8382
Average testing loss: 0.7442
-------------------------------
------------Epoch: 4 ----------------
epoch: 4, iter_num: 100, loss: 0.0064, 15.38%
epoch: 4, iter_num: 200, loss: 0.3630, 30.77%
epoch: 4, iter_num: 300, loss: 0.0475, 46.15%
epoch: 4, iter_num: 400, loss: 0.1398, 61.54%
epoch: 4, iter_num: 500, loss: 0.0512, 76.92%
epoch: 4, iter_num: 600, loss: 0.3366, 92.31%
Epoch: 4, Average training loss: 0.1803
Accuracy: 0.8294
Average testing loss: 0.8796
-------------------------------
------------Epoch: 5 ----------------
epoch: 5, iter_num: 100, loss: 0.0128, 15.38%
epoch: 5, iter_num: 200, loss: 0.0030, 30.77%
epoch: 5, iter_num: 300, loss: 0.2542, 46.15%
epoch: 5, iter_num: 400, loss: 0.0501, 61.54%
epoch: 5, iter_num: 500, loss: 0.6167, 76.92%
epoch: 5, iter_num: 600, loss: 0.2372, 92.31%
Epoch: 5, Average training loss: 0.1330
Accuracy: 0.8294
Average testing loss: 0.9589
-------------------------------
------------Epoch: 6 ----------------
epoch: 6, iter_num: 100, loss: 0.0014, 15.38%
epoch: 6, iter_num: 200, loss: 0.0029, 30.77%
epoch: 6, iter_num: 300, loss: 0.0016, 46.15%
epoch: 6, iter_num: 400, loss: 0.0014, 61.54%
epoch: 6, iter_num: 500, loss: 0.0013, 76.92%
epoch: 6, iter_num: 600, loss: 0.0021, 92.31%
Epoch: 6, Average training loss: 0.0902
Accuracy: 0.8363
Average testing loss: 1.0954
-------------------------------
------------Epoch: 7 ----------------
epoch: 7, iter_num: 100, loss: 0.0009, 15.38%
epoch: 7, iter_num: 200, loss: 0.0130, 30.77%
epoch: 7, iter_num: 300, loss: 0.0011, 46.15%
epoch: 7, iter_num: 400, loss: 0.0229, 61.54%
epoch: 7, iter_num: 500, loss: 0.0024, 76.92%
epoch: 7, iter_num: 600, loss: 0.0031, 92.31%
Epoch: 7, Average training loss: 0.0690
Accuracy: 0.8386
Average testing loss: 1.1462
-------------------------------
------------Epoch: 8 ----------------
epoch: 8, iter_num: 100, loss: 0.0585, 15.38%
epoch: 8, iter_num: 200, loss: 0.0040, 30.77%
epoch: 8, iter_num: 300, loss: 0.0029, 46.15%
epoch: 8, iter_num: 400, loss: 0.0013, 61.54%
epoch: 8, iter_num: 500, loss: 0.1690, 76.92%
epoch: 8, iter_num: 600, loss: 0.0010, 92.31%
Epoch: 8, Average training loss: 0.0476
Accuracy: 0.8278
Average testing loss: 1.2720
-------------------------------
------------Epoch: 9 ----------------
epoch: 9, iter_num: 100, loss: 0.0019, 15.38%
epoch: 9, iter_num: 200, loss: 0.0007, 30.77%
epoch: 9, iter_num: 300, loss: 0.3333, 46.15%
epoch: 9, iter_num: 400, loss: 0.0404, 61.54%
epoch: 9, iter_num: 500, loss: 0.2406, 76.92%
epoch: 9, iter_num: 600, loss: 0.0005, 92.31%
Epoch: 9, Average training loss: 0.0434
Accuracy: 0.8286
Average testing loss: 1.3437
-------------------------------

 【ELECTRA】分类15类的中文预训练模型和tokenizer

from transformers import ElectraTokenizerFast, ElectraForSequenceClassification

# 加载 ELECTRA tokenizer
tokenizer = ElectraTokenizerFast.from_pretrained('hfl/chinese-electra-180g-base-discriminator')

# 加载 ELECTRA 预训练模型
model = ElectraForSequenceClassification.from_pretrained('hfl/chinese-electra-180g-base-discriminator', num_labels=15)

这段代码使用 ElectraTokenizerFast类从 "hfl/chinese-electra-180g-base-discriminator" checkpoint 加载 tokenizer，并使用 ElectraForSequenceClassification类从相同的 checkpoint 加载预训练模型。在这个例子中，该模型用于中文文本分类任务，因此 num_labels 参数被设置为 15，这是数据集中的类别数目。

ELECTRA（中文版）：ELECTRA 是由斯坦福大学提出的新型预训练模型，其训练方法使用了替换和重构两种策略，相较于 BERT 而言，其训练速度较快，且在相同的数据分布下能够获得更好的效果。ELECTRA 的中文版目前也已经发布，你可以通过 Hugging Face 的 Transformers 库来使用。

【SpanBERT】分类15类的中文预训练模型和tokenizer

from transformers import AutoTokenizer, AutoModelForSequenceClassification

# 加载 SpanBERT tokenizer
tokenizer = AutoTokenizer.from_pretrained("SpanBert/spanbert-base-cased")

# 加载 SpanBERT 预训练模型，用于分类任务
model = AutoModelForSequenceClassification.from_pretrained("SpanBert/spanbert-base-cased", num_labels=15)

#——————————————————————————————————————————————————————————————————————————————

from transformers import AutoTokenizer, AutoModelForSequenceClassification

# 加载分类15类 tokenizer
tokenizer = AutoTokenizer.from_pretrained("bert-base-chinese")

# 加载分类15类 SpanBERT 预训练模型，用于分类任务
model = AutoModelForSequenceClassification.from_pretrained("microsoft/SpanBERT-Base-CHinese-15cls", num_labels=15)

这段代码使用 AutoTokenizer 类从 "SpanBert/spanbert-base-cased" checkpoint 加载 tokenizer，并使用 AutoModelForSequenceClassification 类从相同的 checkpoint 加载预训练模型。在这个例子中，该模型用于中文文本分类任务，因此 num_labels 参数被设置为 15，这是数据集中的类别数目。

比bert效果好的文本分类模型：

  1. ALBERT：与BERT具有相似的架构，但使用了一些技巧以减少参数数量，提高训练速度和效果。
  2. XLNet：一种新型的自回归预训练模型，通过排列语言模型任务和掩码语言模型任务相结合的方式进行预训练。
  3. RoBERTa：在BERT的基础上进一步优化，使用更长的训练时间、更大的训练数据和更细致的超参数搜索等策略。
  4. ELECTRA：通过使用对抗性训练来替代BERT中的掩码语言模型任务，从而提高预训练效果。

常见的文本分类模型包括：

  1. 朴素贝叶斯分类器（Naive Bayes Classifier）
  2. 支持向量机分类器（Support Vector Machine Classifier）
  3. 决策树分类器（Decision Tree Classifier）
  4. 随机森林分类器（Random Forest Classifier）
  5. 神经网络分类器（Neural Network Classifier）
  6. 卷积神经网络分类器（Convolutional Neural Network Classifier）
  7. 循环神经网络分类器（Recurrent Neural Network Classifier）
  8. 长短期记忆网络分类器（Long Short-Term Memory Network Classifier）等等。
Jay_27
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Qt无标题窗口
05-21
在本文中，我们将深入探讨如何使用Qt框架创建一个无标题窗口，这在界面设计和自定义标题栏美化中非常有用。我们将关注`framelesswidget.cpp`、`main.cpp`、`framelesswidget.h`等核心文件，理解它们在实现无标题窗口...
Transformers的RoBERTa model怎么使用word level的tokenizer
qysh123的专栏
08-24 1785
不得不说，和上面相比，差别有点大啊（例如：tokenizer = Tokenizer(WordLevel())，以及必需要加tokenizer.pre_tokenizer = Whitespace()这一行）。其实这个问题应该是很好解决的，想不到竟然花了3个多小时。我去，这个原因我也是醉了，所以最后手动建立一个空白的merges.txt文件，然后就可以正常保存和使用这个tokenizer了。从之前说的RoBERTa的示例代码可以知道， 需要再重新加载的tokenizer需要在一个文件夹下，所以这个也不行。
transformers库的使用【二】tokenizer的使用，模型的保存自定义
一个小菜鸟的博客
04-01 1万+
使用标记器（tokenizer） 在之前提到过，标记器（tokenizer）是用来对文本进行预处理的一个工具。 首先，标记器会把输入的文档进行分割，将一个句子分成单个的word（或者词语的一部分，或者是标点符号） 这些进行分割以后的到的单个的word被称为tokens。 第二步，标记器会把这些得到的单个的词tokens转换成为数字，经过转换成数字之后，我们就可以把它们送入到模型当中。 为了实现这种能把tokens转换成数字的功能，标记器拥有一个词表，这个词汇表是在我们进行实例化并指明模型的时候下载
制作TTS前端模型数据集，预训练bert模型的字典数据是怎么调用的-chatgpt问答生成
最新发布
weixin_42831564的博客
06-27 906
这行代码的主要作用是加载和初始化一个预训练的 BERT 中文模型的分词器，使得你可以将自然语言文本转换为模型可以理解的 token 格式，从而进行进一步的自然语言处理任务，如文本分类、命名实体识别等。上述步骤包括数据预处理、数据编码、构建训练数据集和训练模型。通过这些步骤，可以将韵律标签和多音字标签数据转换成可以用于训练 BERT 模型的格式，并进行模型训练以提升 TTS 系统的表现。
AutoTokenizer.from_pretrained 与BertTokenizer.from_pretrained
vivi_cin的博客
03-23 1354
都是 Hugging Face 的 Transformers 库中用于加载预训练模型的 tokenizer 的方法，但它们之间有一些区别。总的来说，如果你想要一个通用的方法来加载任何预训练模型的 tokenizer，你可以使用。但如果你确定你要加载的模型是基于 BERT 结构的，那么。也是一个不错的选择。
怎样通过预训练的Transformers的模型得到一个Sentence的Representation
qysh123的专栏
11-13 1934
这篇博客紧接前面的内容：https://blog.csdn.net/qysh123/article/details/109666416 在我们预训练了Transformers的某个model之后（如RoBERTa），怎么用训练好的model生成某一个句子的Representation呢，其实过程也是很简单的： 在这里看到了有人在问这个问题：https://github.com/huggingface/transformers/issues/2986 其中第一个回答说他写了一篇文章介绍了过程，我仔细看了
Hugging Face Transformers 之 AutoConfig 、AutoTokenizer、AutoModel from_pretrained()参数详解
热门推荐
luckyuxuan的博客
10-25 2万+
Hugging Face Transformers 之 AutoConfig 、AutoTokenizer、AutoModel from_pretrained()参数详解
VC去掉'无标题'字样的方法.zip
11-21
在使用Visual C++进行编程时，我们经常会在创建新的窗口或者对话框时默认看到标题栏显示为“无标题”。这可能会对用户界面的美观性和专业性造成一定的影响。本资料包提供了一种方法来帮助开发者去掉这个“无标题”...
visual c++取掉对话框窗口的 -无标题 字样的方法
08-04
在Visual C++编程环境中，创建窗口应用程序时，默认情况下，窗口标题栏可能会显示“-无标题”字样，这通常是由于没有正确设置窗口类或没有自定义窗口标题所导致的。要解决这个问题，我们需要深入理解Windows API中的...
c#实现无标题栏窗口的拖动
09-05
本篇文章将详细讲解如何在C#中实现这种无标题栏窗口的拖动以及其他基本操作。 首先，为了实现无标题栏窗口的拖动，我们需要处理窗体的鼠标事件。窗体的`FormBorderStyle`属性应设置为`None`，这会去除窗体的边框和...
delphi 无标题调整大小
11-26
在Delphi编程环境中，"无标题调整大小"通常是指创建没有标准标题栏的窗口，并允许用户通过拖动边界来调整其大小。这种设计通常用于自定义界面或创建无边框的对话框。以下是对这个主题的详细解释： 一、创建无标题...
文心ERNIE源码学习与实践：为超越ChatGPT打下技术基础！
skywalk8163的专栏
03-15 4797
ERNIE是百度开创性提出的基于知识增强的持续学习语义理解框架，它将大数据预训练与多源丰富知识相结合，通过持续学习技术，不断吸收海量文本数据中词汇、结构、语义等方面的知识，实现模型效果不断进化。ERNIE在情感分析、文本匹配、自然语言推理、词法分析、阅读理解、智能问答等16个公开数据集上全面显著超越世界领先技术，在国际权威的通用语言理解评估基准GLUE上，得分首次突破90分，获得全球第一。相关创新成果也被国际顶级学术会议AAAI、IJCAI收录。
NLP（五十四）在Keras中使用英文Roberta模型实现文本分类
山阴少年
05-15 5864
本文将会介绍如何将原始torch版本的英文Roberta模型转化为tensorflow版本模型，并且Keras中使用tensorflow版本模型实现英语文本分类。
试试在transformers中调用ERNIE
nghuyong的博客
10-30 1614
ERNIE是什么ERNIE发展路径文心大模型ERNIE是百度发布的产业级知识增强大模型，涵盖了NLP大模型和跨模态大模型。在中文场景下，ERNIE有明显的优势，目前已经发布了一系列模型，包括ERNIE1.0, ERNIE2.0, ERNIE3.0, ERNIE-Gram, ERNIE-Doc等，并且一直在持续更新中。ERNIE官方的代码和模型是PaddlePaddle版本的，具体可以参见：Padd...
在MNLI数据集下的BERT模型训练和评估
mmmmmm儒丶的博客
08-13 606
【代码】在MNLI数据集下的BERT模型训练和评估。
嵌入——实例
Hekena的博客
11-13 887
bert 模型 import tensorflow_hub as hub import tensorflow as tf !pip install tensorflow_text import tensorflow_text as text '''bert_model_hub='https://hub.tensorflow.google.cn/tensorflow/bert_zh_L-12_H-768_A-12/2''' bert_model_hub='https://hub.tensorflow.goog
python-pytorch基础之bert模型分词器tokenizer填充的两种方法
随笔
08-11 751
python-pytorch基础之bert模型分词器tokenizer填充的两种方法
ERNIE快速上手，从一个文本相似度计算任务开始
PaddlePaddle
07-26 1760
点击左上方蓝字关注我们项目背景与相关介绍PaddleNLP是飞桨生态文本领域核心库，具备易用的文本领域API、中文预训练模型集、多场景的应用示例、高性能分布式训练和预测部署能力，旨在提升开...
AutoTokenizer自动加载BERT预训练模型
诗酒趁年华。
03-23 2963
自动加载BERT预训练模型 代码如下： from transformers import (AutoModelForMaskedLM, AutoTokenizer, LineByLineTextDataset, DataCollatorForLanguageModeling, Trainer, TrainingArguments) # 自动加载中文预训练
设置无标题 android
05-02
在Android应用中，设置无标题是一种简洁和美观的设计方式，可以为用户提供更流畅的使用体验。以下是一些实现设置无标题的方法： 1. 在Android的Manifest文件中，找到对应Activity的标签，并添加”android:theme="@android:style/Theme.NoTitleBar"“属性。这样可以通过Android自带的主题去掉标题栏。 2. 使用自定义的主题，可以在样式表中添加以下代码： <style name="AppTheme" parent="Theme.AppCompat.NoActionBar"> <!-- ...其他样式... --> </style> 这种方式可以通过设置主题去除ActionBar和标题栏，同时保留其他布局元素。 3. 去掉代码中的setTitle()方法，这是一种最简单的方法，通过不设置Activity的标题来实现无标题。 以上就是三种常见的实现Android无标题的方式，开发者可以根据实际需求进行选择。值得注意的是，去除标题栏可能会影响用户的导航体验，因此在设计上需要考虑周全。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值