标签：BERT transformers 入门 text 模型 dataset train 使用 True

transformers入门使用

HuggingFace是一个开源社区，它提供了先进的NLP模型，数据集，以及其他工具。

模型：https://huggingface.co/models

数据集：https://huggingface.co/datasets

主要的模型

自然回归： GPT2, Trasnformer-XL, XLNet
自编码: BERT , ALBERT, ROBERTa, ELECTRA
StoS: BART, Pegasus, T5

1 简介

transformers库是一个用于自然语言处理（NLP）的机器学习库，提供了近几年在NLP领域取得巨大成功的预训练模型，例如BERT、GPT、RoBERTa、T5等。

该库由Hugging Face公司开发，是目前最流行的NLP预训练模型库之一。在实际应用中，使用已经训练好的模型可以显著提高模型的效果和速度。

同时，该库还提供了丰富的工具和API，可以帮助用户更方便地使用这些预训练模型，包括文本分类、实体识别、摘要生成、文本翻译等各种NLP任务。

transformers库支持多种主流深度学习框架，例如PyTorch、Tensorflow等，用户可以根据自己的喜好选择相应的框架进行使用。

BERT（Bidirectional Encoder Representations from Transformers）是一种用于自然语言处理（NLP）的预训练模型。它是在2018年由Google发布的，并被认为是最具革命性的NLP模型之一。BERT模型是基于Transformer网络结构的，并使用了一种预训练的方法来学习上下文相关的词向量表示。

BERT模型的目标是让一个模型具有理解自然语言的能力，而不是人为地将所有知识和规则硬编码到算法中。这种目标是通过对巨型文本数据集进行预训练来实现的。BERT可以学习从一个句子到另一个句子的上下文语境，因此可以更好地处理自然语言。

BERT模型的架构涵盖了两个阶段：预训练和微调。

预训练：在预训练阶段中，BERT模型利用无监督的方式从海量的文本数据中学习常识。在这个过程中，模型先使用“掩码语言模型”（Masked Language Model，MLM）来训练模型，然后再使用“下一句预测模型”（Next Sentence Prediction，NSP）来进一步提高模型的性能。MLM使BERT模型学会推断词语中被遮盖的部分，而NSP是让BERT模型对文本对的关系进行预测，是一个判断文本连贯性的过程。预训练过程中，BERT模型可处理各种类型的文本数据，包括电子邮件、网页、微博、评论等等。
微调：微调阶段是指将预训练的模型用于实际任务，并根据实际任务的目标对模型进行微调。BERT模型的微调可以应用于多种自然语言处理任务，包括情感分析、自动问答、文本分类等等。

BERT模型的优点是它可以处理各种不规则文本数据，并提供比以前的NLP模型更加准确和有用的结果，因为BERT能够建立更好的理解自然语言的语境。此外，BERT还有一个优点是它开放源代码，可以自由使用和修改，方便大家进行相关研究和开发。

2 分词器 transformers.BertTokenizer

BERT 分词器是一种自然语言处理工具，主要用于将文本数据进行分词、词性标注、实体识别、句子划分等预处理操作。

具体来说，BERT 分词器的作用包括以下几个方面：

分词：将文本中的连续字符串按照一定规则划分成单个的词语，常用的算法有最大匹配、最小匹配、双向匹配等。
词性标注：对每个词语进行词性标注，例如名词、动词、形容词等，有助于后续的语义分析。
实体识别：识别文本中的人名、地名、组织机构名等实体，为知识图谱构建和命名实体识别等任务提供数据基础。
句子划分：将整篇文本按照句子结构进行划分，为文本分类、情感分析等任务提供语义单元划分的基础。

BERT 分词器编码句子的作用：

BERT 分词器在进行分词时，不仅仅是将每个单词转化为固定的编号，而是将整个句子编码为一个向量。这是因为句子的语义信息往往不仅仅取决于每个单词的意义，还和上下文有关。编码句子可以使得句子的语义信息包含在向量中，有助于后续的自然语言处理任务。
具体来说，BERT 分词器采用的是 Transformer 模型，这种模型可以将句子作为输入，经过多层自注意力（self-attention）机制的加工，得到一个表示整个句子的向量，称为句子嵌入（sentence embedding）向量。这种方法可以同时考虑每个单词的上下文信息，而且还可以避免传统的词向量模型中单词之间的相关性计算问题。
通过编码句子，BERT 分词器为后续的自然语言处理任务提供了更丰富的语义信息。而且由于 BERT 分词器是基于预训练的方式进行编码句子，其能力可以应用到多个自然语言处理任务中，从而实现了更广泛的语义理解和处理。

总的来说，BERT 分词器的主要作用是将自然语言文本进行可处理的单元划分，为后续的BERT 模型自然语言处理任务提供数据基础。

下面是分词器的代码演示：

from transformers import BertTokenizer

# 加载分词器
tokenizer = BertTokenizer.from_pretrained(
    pretrained_model_name_or_path='bert-base-chinese',
    cache_dir=None,
    force_download=False,
)

# 待编码的句子
sents = [
    '选择珠江花园的原因就是方便。',
    '笔记本的键盘确实爽。',
    '房间太小。其他的都一般。',
    '今天才知道这书还有第6卷,真有点郁闷.',
    '机器背面似乎被撕了张什么标签，残胶还在。',
]

tokenizer, sents

2.1 简单编码

简单编码，一次可以编码一个句子或者两个句子。

分词器的encode方法可以将tokens编码成ids.

# 编码两个句子
input_ids = tokenizer.encode(
    text=sents[0],  # 句子1
    text_pair=sents[1],  # 句子2
    truncation=True,  # 当句子长度大于max_length时,截断
    padding='max_length',  # 一律补pad到max_length长度
    add_special_tokens=True,
    max_length=30,  # 最大长度
    return_tensors=None,   # 返回list
)

print(input_ids)

tokenizer.decode(input_ids)

"""
句子编码后的结果：
[101, 6848, 2885, 4403, 3736, 5709, 1736, 4638, 1333, 1728, 2218, 3221, 3175, 912, 511, 102, 5011, 6381, 3315, 4638, 7241, 4669, 4802, 2141, 4272, 511, 102, 0, 0, 0]

解码：
'[CLS] 选 择 珠 江 花 园 的 原 因 就 是 方 便 。 [SEP] 笔 记 本 的 键 盘 确 实 爽 。 [SEP] [PAD] [PAD] [PAD]'
"""

2.2 增强编码

# 增强的编码
out = tokenizer.encode_plus(
    text=sents[0],  # 句子1
    text_pair=sents[1],  # 句子2
    truncation=True,  # 当句子长度大于max_length时,截断
    padding='max_length',  # 一律补零到max_length长度
    max_length=30,  # 最大长度
    add_special_tokens=True,
    return_tensors=None,  # 可取值tf,pt,np,默认为返回list
    return_token_type_ids=True,  # 返回token_type_ids
    return_attention_mask=True,  # 返回attention_mask
    return_special_tokens_mask=True,  # 返回special_tokens_mask 特殊符号标识
    #返回offset_mapping 标识每个词的起止位置,这个参数只能BertTokenizerFast使用
    #return_offsets_mapping=True,
    #返回length 标识长度
    return_length=True,
)

# input_ids           就是编码后的词
# token_type_ids      第一个句子和特殊符号的位置是0,第二个句子的位置是1
# special_tokens_mask 特殊符号的位置是1,其他位置是0
# attention_mask      pad的位置是0,其他位置是1
# length             返回句子长度
for k, v in out.items():
    print(k, ':', v)
    
"""
input_ids : [101, 6848, 2885, 4403, 3736, 5709, 1736, 4638, 1333, 1728, 2218, 3221, 3175, 912, 511, 102, 5011, 6381, 3315, 4638, 7241, 4669, 4802, 2141, 4272, 511, 102, 0, 0, 0]
token_type_ids : [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0]
special_tokens_mask : [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1]
attention_mask : [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0]
length : 30
"""

# 解码
tokenizer.decode(out['input_ids'])
"""
'[CLS] 选 择 珠 江 花 园 的 原 因 就 是 方 便 。 [SEP] 笔 记 本 的 键 盘 确 实 爽 。 [SEP] [PAD] [PAD] [PAD]'
"""

2.3 批量增强编码

第一种：

# 批量编码句子
out = tokenizer.batch_encode_plus(
    batch_text_or_text_pairs=[sents[0], sents[1]],  # 编码两个句子
    add_special_tokens=True,  # 特殊符号的位置是1,其他位置是0
    truncation=True,  # 当句子长度大于max_length时,截断
    padding='max_length',  # 不足最大长度时， 一律补零到max_length长度
    max_length=15,  # 最大长度
    return_tensors=None,  # 可取值tf,pt,np,默认为返回list
    return_token_type_ids=True,  # 返回token_type_ids 第一个句子和特殊符号的位置是0,第二个句子的位置是1
    return_attention_mask=True,  # 返回attention_mask pad(不足最大长度补0)的位置是0,其他位置是1
    return_special_tokens_mask=True,  # 返回special_tokens_mask 特殊符号标识
    # 返回offset_mapping 标识每个词的起止位置,这个参数只能BertTokenizerFast使用
    # return_offsets_mapping=True,
    # 返回length 标识长度
    return_length=True,
)

# input_ids           就是编码后的词
# token_type_ids      第一个句子和特殊符号的位置是0,第二个句子的位置是1
# special_tokens_mask 特殊符号的位置是1,其他位置是0
# attention_mask      pad的位置是0,其他位置是1
# length             返回句子长度
for k, v in out.items():
    print(k, ':', v)
    
"""
input_ids : [[101, 6848, 2885, 4403, 3736, 5709, 1736, 4638, 1333, 1728, 2218, 3221, 3175, 912, 102], [101, 5011, 6381, 3315, 4638, 7241, 4669, 4802, 2141, 4272, 511, 102, 0, 0, 0]]
token_type_ids : [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
special_tokens_mask : [[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1]]
length : [15, 12]
attention_mask : [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0]]
"""

# 解码两个句子
tokenizer.decode(out['input_ids'][0]), 
"""
'[CLS] 选 择 珠 江 花 园 的 原 因 就 是 方 便 [SEP]'
"""

tokenizer.decode(out['input_ids'][1])
"""
'[CLS] 笔 记 本 的 键 盘 确 实 爽 。 [SEP] [PAD] [PAD] [PAD]'
"""

第二种：

# 批量编码成对的句子
out = tokenizer.batch_encode_plus(
    batch_text_or_text_pairs=[(sents[0], sents[1]), (sents[2], sents[3])],  # 可以编码成对的多种组合 
    add_special_tokens=True,
    truncation=True,  # 当句子长度大于max_length时,截断
    padding='max_length',  # 不足最大长度的位置，补到最大长度
    max_length=30,  # 最大长度
    return_tensors=None,  # 可取值tf,pt,np,默认为返回list
    return_token_type_ids=True,  # 返回token_type_ids
    return_attention_mask=True,  # 返回attention_mask
    #返回special_tokens_mask 特殊符号标识
    return_special_tokens_mask=True,
    # 返回offset_mapping 标识每个词的起止位置,这个参数只能BertTokenizerFast使用
    # return_offsets_mapping=True,
    # 返回length 标识长度
    return_length=True,
)

# input_ids           就是编码后的词
# token_type_ids      第一个句子和特殊符号的位置是0,第二个句子的位置是1
# special_tokens_mask 特殊符号的位置是1,其他位置是0
# attention_mask      pad的位置是0,其他位置是1
# length             返回句子长度
for k, v in out.items():
    print(k, ':', v)

"""
input_ids : [[101, 6848, 2885, 4403, 3736, 5709, 1736, 4638, 1333, 1728, 2218, 3221, 3175, 912, 511, 102, 5011, 6381, 3315, 4638, 7241, 4669, 4802, 2141, 4272, 511, 102, 0, 0, 0], [101, 2791, 7313, 1922, 2207, 511, 1071, 800, 4638, 6963, 671, 5663, 511, 102, 791, 1921, 2798, 4761, 6887, 6821, 741, 6820, 3300, 5018, 127, 1318, 117, 4696, 3300, 102]]
token_type_ids : [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]
special_tokens_mask : [[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1], [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]]
length : [27, 30]
attention_mask : [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]
"""

# 解码
tokenizer.decode(out['input_ids'][0])
"""
'[CLS] 选 择 珠 江 花 园 的 原 因 就 是 方 便 。 [SEP] 笔 记 本 的 键 盘 确 实 爽 。 [SEP] [PAD] [PAD] [PAD]'
"""

tokenizer.decode(out['input_ids'][1])
"""
'[CLS] 房 间 太 小 。 其 他 的 都 一 般 。 [SEP] 今 天 才 知 道 这 书 还 有 第 6 卷, 真 有 [SEP]'
"""

2.4 字典操作

# 获取字典
zidian = tokenizer.get_vocab()  # {token: id, ...}
type(zidian), len(zidian), '月光' in zidian  # (dict, 21128, False)
'月' in zidian, '光' in zidian  # (True, True) 
# 月和光都在字典中， 但月光不在字典中
# 添加新词
tokenizer.add_tokens(new_tokens=['月光', '希望'])

# 添加新符号
tokenizer.add_special_tokens({'eos_token': '[EOS]'})

zidian = tokenizer.get_vocab()
type(zidian), len(zidian), zidian['月光'], zidian['[EOS]']  # (dict, 21131, 21128, 21130)

# 编码新添加的词
out = tokenizer.encode(
    text='月光的新希望[EOS]',
    text_pair=None,
    truncation=True,  # 当 句子长度大于max_length时,截断
    padding='max_length',  # 不足最大长度时，一律补pad到max_length长度
    add_special_tokens=True,
    max_length=8,  # 最大长度
    return_tensors=None,
)

print(out)  # [101, 21128, 4638, 3173, 21129, 21130, 102, 0]

tokenizer.decode(out)  # '[CLS] 月光 的 新 希望 [EOS] [SEP] [PAD]'

3 transformers 模型使用

使用transformers库主要分为以下几个步骤：

安装transformers库

可以使用pip命令安装transformers库：

pip install transformers

加载预训练模型

使用transformers库需要先加载相应的预训练模型。可以从Hugging Face网站上下载相应的模型，也可以通过API从transformers库中直接下载预训练模型。

加载预训练模型的代码示例：

from transformers import BertModel, BertTokenizer

model_name = 'bert-base-uncased'
tokenizer = BertTokenizer.from_pretrained(model_name)
model = BertModel.from_pretrained(model_name)

以上代码使用了BERT模型进行加载，加载过程中同样进行了对应的tokenization操作。

使用预训练模型进行NLP任务

加载预训练模型后，即可使用其进行NLP任务，例如文本分类、命名实体识别、序列标注、文本生成等。

以BERT模型进行文本分类为例的代码示例：

from transformers import BertForSequenceClassification, BertTokenizer

model_name = 'bert-base-uncased'
tokenizer = BertTokenizer.from_pretrained(model_name)
model = BertForSequenceClassification.from_pretrained(model_name)

inputs = tokenizer("This is a sentence", return_tensors="pt")
outputs = model(**inputs)

logits = outputs.logits

以上代码使用了已经加载好的BERT模型进行文本分类，输入了一个句子，并返回了该句子的分类概率（logits）。

fine-tune预训练模型

使用预训练模型进行迁移学习，可以针对任务领域的特定数据进行fine-tune。fine-tune是指在预训练模型的基础上，针对特定数据集进行进一步的训练，以适应特定的数据和任务。

以下是使用BERT进行情感分类fine-tune的代码示例：

from transformers import BertForSequenceClassification, BertTokenizer, AdamW
import torch

# 1. 加载数据集，假设训练集和验证集已经准备好了
train_data = ...
valid_data = ...

# 2. 加载预训练模型和tokenizer
model_name = 'bert-base-uncased'
tokenizer = BertTokenizer.from_pretrained(model_name)
model = BertForSequenceClassification.from_pretrained(model_name)

# 3. 使用GPU进行模型训练
device = 'cuda' if torch.cuda.is_available() else 'cpu'
model.to(device)

# 4. 设置训练参数
epochs = 5
batch_size = 16
optimizer = AdamW(model.parameters(), lr=2e-5)

# 5. 开始训练
for epoch in range(epochs):
    # 6. 训练集batch循环
    for i in range(0, len(train_data), batch_size):
        # 6.1 批处理  训练数据
        batch = train_data[i:i+batch_size]
        # 6.2 分词器编码
        inputs = tokenizer.batch_encode_plus(batch, return_tensors="pt", padding=True, truncation=True)
        inputs.to(device)
        # 6.3 张量处理 labels
        labels = torch.tensor([d['label'] for d in batch]).to(device)
        # 6.4 训练
        outputs = model(input_ids=inputs['input_ids'], token_type_ids=inputs['token_type_ids'], attention_mask=inputs['attention_mask'], labels=labels)
        # 6.5 损失函数
        loss = outputs.loss
        # 6.6 反向传播 计算梯度
        loss.backward()
        # 6.7 参数更新
        optimizer.step()
        # 6.8 梯度置为0
        optimizer.zero_grad()

    # 7. 验证集batch循环
    with torch.no_grad():  # 模型评估不需要计算梯度
        for i in range(0, len(valid_data), batch_size):
            # 7.1 验证集批处理
            batch = valid_data[i:i+batch_size]
            # 7.2 验证集分词器编码
            inputs = tokenizer.batch_encode_plus(batch, return_tensors="pt", padding=True, truncation=True)
            inputs.to(device)
            # 7.3 验证集 labels 转 张量
            labels = torch.tensor([d['label'] for d in batch]).to(device)
            # 7.4 预测
            outputs = model(input_ids=inputs['input_ids'], token_type_ids=inputs['token_type_ids'], attention_mask=inputs['attention_mask'], labels=labels)
            # 7.5 计算损失
            loss = outputs.loss

    # 8. 打印一些训练过程中的指标
    print(f"Epoch {epoch} training loss: {loss.item()}")

以上代码中，针对情感分类任务的数据集，使用fine-tune技术对BERT模型进行了训练，并输出了训练过程中的损失。

以上代码加载了BERT模型和tokenizer，并使用fine-tune技术在情感分类数据集上进行了训练。

4 数据集操作 datasets

4.1 load_dataset

from datasets import load_dataset

# 加载数据
# 注意：如果你的网络不允许你执行这段的代码，则直接运行【从磁盘加载数据】即可
# 转载自seamew/ChnSentiCorp, 或者传入本地数据数据集文件路径
dataset = load_dataset(path='lansinuote/ChnSentiCorp')  # 从网络上下载数据集

dataset
"""数据集结构
DatasetDict({
    train: Dataset({
        features: ['text', 'label'],
        num_rows: 9600
    })
    test: Dataset({
        features: ['text', 'label'],
        num_rows: 1200
    })
    validation: Dataset({
        features: ['text', 'label'],
        num_rows: 1200
    })
})
"""

4.2 save_to_disk

# save_to_disk 保存数据集到磁盘
#注意：运行这段代码要确保【加载数据】运行是正常的，否则直接运行【从磁盘加载数据】即可
dataset.save_to_disk(dataset_dict_path='./data/ChnSentiCorp')

4.3 load_from_disk

从磁盘加载数据

# 从磁盘加载数据
from datasets import load_from_disk

dataset = load_from_disk('./data/ChnSentiCorp')

dataset

4.4 获取训练集测试集验证集

# 获取 训练集 测试集 验证集
# 获取训练集
dataset_train = dataset['train']
# 获取测试集
dataset_test = dataset['test']
# 获取验证集
dataset_val = dataset['validation']

# 查看一条数据
dataset_train[0]
"""
{'text': '选择珠江花园的原因就是方便，有电动扶梯直接到达海边，周围餐馆、食廊、商场、超市、摊位一应俱全。酒店装修一般，但还算整洁。 泳池在大堂的屋顶，因此很小，不过女儿倒是喜欢。 包的早餐是西式的，还算丰富。 服务吗，一般', 'label': 1}
"""

4.5 sort

排序

# 4. 查看一条数据
dataset_train[0]
"""
{'text': '选择珠江花园的原因就是方便，有电动扶梯直接到达海边，周围餐馆、食廊、商场、超市、摊位一应俱全。酒店装修一般，但还算整洁。 泳池在大堂的屋顶，因此很小，不过女儿倒是喜欢。 包的早餐是西式的，还算丰富。 服务吗，一般', 'label': 1}
"""

# 未排序的label是乱序的
print(dataset_train['label'][:10])  # [1, 1, 0, 0, 1, 0, 0, 0, 1, 1]

# 排序之后label有序了
sorted_dataset = dataset_train.sort('label')
print(sorted_dataset['label'][:10])  # [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
print(sorted_dataset['label'][-10:])  # [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

4.6 shuffle

打乱顺序

#打乱顺序
shuffled_dataset = sorted_dataset.shuffle(seed=42)
shuffled_dataset['label'][:10]  # [0, 1, 0, 0, 1, 0, 1, 0, 1, 0]

4.7 select

选择

dataset_train.select([0, 10, 20, 30, 40, 50])

"""
Dataset({
    features: ['text', 'label'],
    num_rows: 6
})
"""

4.8 filter

过滤

def f(data):
    return data['text'].startswith('选择')


start_with_ar = dataset_train.filter(f)

4.9 train_test_split

切割训练集和训练集

dataset_train.train_test_split(test_size=0.1)  # 0.1 表示测试集占01
"""
DatasetDict({
    train: Dataset({
        features: ['text', 'label'],
        num_rows: 8640
    })
    test: Dataset({
        features: ['text', 'label'],
        num_rows: 960
    })
})
"""

4.10 shard

将数据集均匀切分

# 切分前
"""dataset_train
Dataset({
     features: ['text', 'label'],
     num_rows: 9600
 })
"""
# 把数据切分到4个桶中,均匀分配
dataset_train.shard(num_shards=4, index=0)
"""
Dataset({
     features: ['text', 'label'],
     num_rows: 2400
 })
"""

4.11 rename_column

重名列名

dataset_train.rename_column('text', 'textA')
"""
Dataset({
    features: ['textA', 'label'],
    num_rows: 9600
})
"""

4.12 remove_columns

移除列

dataset_train.remove_columns(['text'])
"""
Dataset({
    features: ['label'],
    num_rows: 9600
})
"""

4.13 map

值映射：逐次修改每个元素值

def f(data):
    data['text'] = 'My sentence: ' + data['text']
    return data


dataset_train_map = dataset_train.map(f)

dataset_train_map['text'][:5]

4.14 set_format

设置格式

dataset.set_format(type='torch', columns=['label'])

dataset[0]
"""
{'label': tensor(1)}
"""

4.15 加载或导出csv文件

# 从网络上加载数据
dataset = load_dataset(path='lansinuote/ChnSentiCorp', split='train')
# 保存csv文件
dataset.to_csv(path_or_buf='./data/ChnSentiCorp.csv')

# 加载csv格式数据
csv_dataset = load_dataset(path='csv',
                           data_files='./data/ChnSentiCorp.csv',
                           split='train')
csv_dataset[20]
"""
{'text': '非常不错，服务很好，位于市中心区，交通方便，不过价格也高！', 'label': 1}
"""

4.16 加载或导出json文件

# 从网络上加载数据
dataset = load_dataset(path='lansinuote/ChnSentiCorp', split='train')
# 保存csv文件
dataset.to_json(path_or_buf='./data/ChnSentiCorp.json')

#加载json格式数据
json_dataset = load_dataset(path='json',
                            data_files='./data/ChnSentiCorp.json',
                            split='train')
json_dataset[20]
"""
{'text': '非常不错，服务很好，位于市中心区，交通方便，不过价格也高！', 'label': 1}
"""

4.17 评价指标 evaluate库

地址：https://huggingface.co/docs/evaluate

有哪些评价指标呢？

from datasets import list_metrics

# 列出评价指标
metrics_list = list_metrics()

print(len(metrics_list))  # 121
print(metrics_list)

如何使用评价指标，上面列出的121种评价指标，选择其中一个合适的指标即可，由于load_metric已弃用，并将在数据集的下一个datasets主要版本中删除，因此需要安装新库评价evaluate库：pip install evaluate

# from datasets import load_metric
# 未来警告：load_metric已弃用，并将在数据集的下一个主要版本中删除。改用“evaluate.load”，从新库中
标签：BERT,transformers,入门,text,模型,dataset,train,使用,True	

From： https://www.cnblogs.com/itelephant/p/17451875.html

transformers入门使用

transformers入门使用

1 简介

2 分词器 transformers.BertTokenizer

2.1 简单编码

2.2 增强编码

2.3 批量增强编码

2.4 字典操作

3 transformers 模型使用

4 数据集操作 datasets

4.1 load_dataset

4.2 save_to_disk

4.3 load_from_disk

4.4 获取训练集测试集验证集

4.5 sort

4.6 shuffle

4.7 select

4.8 filter

4.9 train_test_split

4.10 shard

4.11 rename_column

4.12 remove_columns

4.13 map

4.14 set_format

4.15 加载或导出csv文件

4.16 加载或导出json文件

4.17 评价指标 evaluate库

相关文章

赞助商

阅读排行

transformers入门使用

transformers入门使用

1 简介

2 分词器 transformers.BertTokenizer

2.1 简单编码

2.2 增强编码

2.3 批量增强编码

2.4 字典操作

3 transformers 模型使用

4 数据集操作 datasets

4.1 load_dataset

4.2 save_to_disk

4.3 load_from_disk

4.4 获取 训练集 测试集 验证集

4.5 sort

4.6 shuffle

4.7 select

4.8 filter

4.9 train_test_split

4.10 shard

4.11 rename_column

4.12 remove_columns

4.13 map

4.14 set_format

4.15 加载或导出csv文件

4.16 加载或导出json文件

4.17 评价指标 evaluate库

相关文章

赞助商

阅读排行

4.4 获取训练集测试集验证集