Hugging face Transformers（3）—— Tokenizer

最新推荐文章于 2024-07-23 10:37:26 发布
最新推荐文章于 2024-07-23 10:37:26 发布
阅读量1.1k 收藏 23
点赞数 22
分类专栏： # Transformers 文章标签： Hugging Face Tokenizer Transformers
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wxc971231/article/details/140234490
版权
  • Hugging Face 是一家在 NLP 和 AI 领域具有重要影响力的科技公司，他们的开源工具和社区建设为NLP研究和开发提供了强大的支持。它们拥有当前最活跃、最受关注、影响力最大的 NLP 社区，最新最强的 NLP 模型大多在这里发布和开源。该社区也提供了丰富的教程、文档和示例代码，帮助用户快速上手并深入理解各类 Transformer 模型和 NLP 技术
  • Transformers 库是 Hugging Face 最著名的贡献之一，它最初是 Transformer 模型的 pytorch 复现库，随着不断建设，至今已经成为 NLP 领域最重要，影响最大的基础设施之一。该库提供了大量预训练的模型，涵盖了多种语言和任务，成为当今大模型工程实现的主流标准，换句话说，如果你正在开发一个大模型，那么按 Transformer 库的代码格式进行工程实现、将 check point 打包成 hugging face 格式开源到社区，对于推广你的工作有很大的助力作用。本系列文章将介绍 Transformers库 的基本使用方法
  • 前文：Hugging face Transformers（2）—— Pipeline

文章目录

1. Tokenizer 及其基本使用

  • Tokenizer 是将原始字符串转换为模型可以计算的数值形式（通常是 token IDs）的工具。不同的模型可能需要不同的 tokenizer，因为不同的预训练任务和数据集可能会导致不同的词汇表（vocabulary）和 tokenization 策略。
  • Tokenizer 用于数据预处理，其作用包括
    1. 分词：使用分词器对文本数据进行分词 (字、字词)
    2. 构建词典：根据数据集分词的结果，构建词典映射 (这步并不绝对，如果采用预训练词向量，词典映射要根据词向量文件进行处理)
    3. 数据转换：根据构建好的词典，将分词处理后的数据做映射，将文本序列转换为数字序列。其中可能涉及添加特殊标记（如 [CLS]、[SEP]、[MASK] 等），以便模型能够识别文本的不同部分或执行特定的任务（如分类、问答等）
    4. 数据填充与截断：在以batch输入到模型的方式中，需要对过短的数据进行填充，过长的数据进行截断，保证数据长度符合模型能接受的范围，同时batch内的数据维度大小一致

1.1 保存与加载

  • 如前文 Hugging face Transformers（2）—— Pipeline 3.2 节所述，可以用 AutoTokenizer 自动类，从模型地址直接识别、创建并初始化所需的 tokenizer 对象。这里我们还是使用前文的中文情感分类模型的 tokenizer
    # AutoTokenizer 包可以根据传入的参数（如模型名）自动判断所需的 tokenizer
from transformers import AutoTokenizer

# 样例字符串
sen = "这是一段测试文本"

# 从 hugging face 加载，输入模型名称即可加载对应的分词器
tokenizer = AutoTokenizer.from_pretrained("uer/roberta-base-finetuned-dianping-chinese")
tokenizer

    BertTokenizerFast(name_or_path='uer/roberta-base-finetuned-dianping-chinese', vocab_size=21128, model_max_length=1000000000000000019884624838656, is_fast=True, padding_side='right', truncation_side='right', special_tokens={'unk_token': '[UNK]', 'sep_token': '[SEP]', 'pad_token': '[PAD]', 'cls_token': '[CLS]', 'mask_token': '[MASK]'}, clean_up_tokenization_spaces=True),  added_tokens_decoder={
	0: AddedToken("[PAD]", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	100: AddedToken("[UNK]", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	101: AddedToken("[CLS]", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	102: AddedToken("[SEP]", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	103: AddedToken("[MASK]", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
}
    从打印信息可见，这是一个 BERT 模型的 Tokenizer，其中有五个特殊符号，在右侧进行填充或截断…
  • 第一次创建 Tokenizer 对象时，词表等相关配置文件会下载并保存至默认路径 C:\Users\username\.cache\huggingface\hub，之后会默认从此处重新加载。可以将构造的 tokenizer 对象手动保存到指定路径，并从指定路径加载
    # 自动下载的 model 和 tokenizer 等组件位于 C:\Users\username\.cache\huggingface\hub 中
# 可以把 tokenizer 单独保存到指定路径
tokenizer.save_pretrained("./roberta_tokenizer")

# 可以从本地加载保存的 tokenizer
tokenizer = AutoTokenizer.from_pretrained("./roberta_tokenizer")

1.2 句子分词

  • Tokenizer 工作的第一步是文本分割，即将原始输入字符串拆开成一系列字符、词、字节码或短句（称之为token）。在中文自然语言处理中，分词尤为重要，因为中文的词与词之间没有空格这样明显的分隔符。

  • 根据分词方法不同，对应的词表也会有所区别。一般而言，较大的词表可以包含更多的词汇，有助于模型更好地理解和表达文本，提高模型性能，增强泛化能力。然而，随着词表尺寸的增加，模型的计算复杂度和内存需求也会相应增加。可以通过 Tokenizer 对象的 .vocab 属性查看词表

    tokenizer.vocab

    {'##净': 14169,
 'ま': 567,
 '##copyright': 13291,
 '疡': 4550,
 '抢': 2843,
 '枇': 3355,
 '##尘': 15269,
 '贺': 6590,
 'ne': 10564,
 '庸': 2435,
 '##馬': 20736,
 '臾': 5640,
 '勖': 1241,
 '##粱': 18175,
 '##⒋': 13574,
 '褥': 6191,
 'doc': 9656,
 '釁': 7022,
 'alex': 10179,
 '##フト': 10868,
 '屹': 2256,
 'yumi': 11697,
 '##nne': 12866,
 '莫': 5811,
 '816': 10937,
...
 '##躍': 19770,
 '皺': 4653,
 '##ろ': 10460,
 '##孪': 15169,
 ...}

  • Transformers 库的 tokenizer 支持传入原始字符串或原始字符串列表，如下所示

    tokens = tokenizer.tokenize(sen)
print(tokens)   # ['这', '是', '一', '段', '测', '试', '文', '本']

tokens = tokenizer.tokenize([sen, sen])
print(tokens)   # ['这', '是', '一', '段', '测', '试', '文', '本', '这', '是', '一', '段', '测', '试', '文', '本']

1.3 索引转换

  • 只进行分词，得到的还是一些字符串和字符对象，还需要进行一步索引转换才能变成可计算的数值数据。所谓索引转换，其实就是把分词结果一一替换为词表中的索引（称之为 token id），之后在做 embedding 的时候，这些 id 会先转换为 one-hot 向量，再通过线性层投影到嵌入空间（也称为 lookup table 操作），此后就可以在隐空间向量上进行注意力计算了
  • 结合 1.2 节的分词和索引转换，完整的 tokenize 过程如下
    # Tokenize流程：原始字符串 -> token 序列 -> id 序列
tokens = tokenizer.tokenize(sen)
ids = tokenizer.convert_tokens_to_ids(tokens)
print(ids)		# [6821, 3221, 671, 3667, 3844, 6407, 3152, 3315]

# 也可以逆向操作：id 序列-> token 序列
tokens = tokenizer.convert_ids_to_tokens(ids)
print(tokens)	# ['这', '是', '一', '段', '测', '试', '文', '本']

# 也可以逆向操作：token 序列 -> 字符串
str_sen = tokenizer.convert_tokens_to_string(tokens)
print(str_sen)	# 这 是 一 段 测 试 文 本
  • Transformers 库还提供称为 “编码” 和 “解法” 的简便方法，实现从原始字符串到 id 序列相互转换的一步操作
    # “编码”: 原始字符串 -> id 序列
ids = tokenizer.encode(sen, add_special_tokens=True)        # add_special_tokens 在 tokenize 时序列设置特殊 token
print(ids)                                                  # 注意到首尾多了特殊 token [CLS](101) 和 [SEP](102)
# “解码”：id 序列 -> 原始字符串
str_sen = tokenizer.decode(ids, skip_special_tokens=False)  # skip_special_tokens 可以跳过可能存在的特殊 token
print(str_sen)
str_sen = tokenizer.decode(ids, skip_special_tokens=True)
print(str_sen)

'''
[101, 6821, 3221, 671, 3667, 3844, 6407, 3152, 3315, 102]
[CLS] 这 是 一 段 测 试 文 本 [SEP]
这 是 一 段 测 试 文 本
'''
    注意，在 encode 方法传入 add_special_tokens 参数；在 decode 方法传入 skip_special_tokens 参数，可以控制特殊 token 的引入和跳过

1.4 截断和填充

  • 通常使用 batch 形式训练 Transformer 类模型，这要求我们把序列数据长度全部处理成和模型输入一致的状态。为此，需要进行截断或填充操作
    # 填充
ids = tokenizer.encode(sen, padding="max_length", max_length=15)
print(ids)  # [101, 6821, 3221, 671, 3667, 3844, 6407, 3152, 3315, 102, 0, 0, 0, 0, 0]

# 截断
ids = tokenizer.encode(sen, max_length=5, truncation=True)
print(ids)  # [101, 6821, 3221, 671, 102]
ids = tokenizer.encode(sen, max_length=5, truncation=False)	# 禁止截断则正常做 tokenize
print(ids)  # [101, 6821, 3221, 671, 3667, 3844, 6407, 3152, 3315, 102]
  • 如上所示，通过在 encode 方法传入 max_length 参数控制最终序列长度，通过 padding 参数控制填充类型。注意到该 tokenizer 是在右侧进行 zero-padding 的，该设置可以在 1.1 节的 tokenizer 信息中观察到。另外，可以通过 truncation 参数控制是否截断

1.5 附加输入信息

  • 通常，Transformer 类模型的前向过程不止需要 token id，还需要各个 token id 的一些附加信息。比如在 BERT 的上下句预训练任务中，需要明确各个 token 所属的上下句信息；还需要 attention_mask 遮盖 zero padding 的部分，这些信息我们可以手动构造
    ids = tokenizer.encode(sen, padding="max_length", max_length=15)

# 除 token 外，Transformer 类模型的输入往往还有一些附加信息
attention_mask = [1 if idx != 0 else 0 for idx in ids]  # attention_mask 用于遮盖 zero padding 部分
token_type_ids = [0] * len(ids)                         # bert 有一个判断上下句任务，模型预训练时需要 token 所属句子 id 信息
ids, attention_mask, token_type_ids

    ([101, 6821, 3221, 671, 3667, 3844, 6407, 3152, 3315, 102, 0, 0, 0, 0, 0],
 [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, 0, 0, 0])
  • Transformers 库中，这些附件信息的生成方法被集成到 tokenizer 的实现中，通过 tokenizer.encode_plus() 方法或直接 tokenizer() 形式调用
    # 附加信息无需手动编写，tokenizer 中已经提供
inputs = tokenizer.encode_plus(sen, padding="max_length", max_length=15)
print(inputs)	# {'input_ids': [101, 6821, 3221, 671, 3667, 3844, 6407, 3152, 3315, 102, 0, 0, 0, 0, 0], 'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0]}


# 另一种调用方法
inputs = tokenizer(sen, padding="max_length", max_length=15)
print(inputs)	# {'input_ids': [101, 6821, 3221, 671, 3667, 3844, 6407, 3152, 3315, 102, 0, 0, 0, 0, 0], 'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0]}

1.6 处理 batch 数据

  • 前文 1.2 节提到过，tokenizer 支持字符串和字符串列表形式的输入，其中后者是为了 batch 数据而专门设计的，可以有效提高 tokenize 效率。基本使用如下

    sens = [
    "AABBCCDDEEFF",
    "哈哈哈哈哈哈哈哈哈哈哈",
    "你好你好你好你好"
]
res = tokenizer(sens)	# batch tokenize 不要求各原始字符串长度一致
res

    {'input_ids': [[101, 9563, 10214, 8860, 9879, 8854, 9049, 102], [101, 1506, 1506, 1506, 1506, 1506, 1506, 1506, 1506, 1506, 1506, 1506, 102], [101, 872, 1962, 872, 1962, 872, 1962, 872, 1962, 102]], '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, 0]], '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, 1, 1, 1, 1]]}

  • 对比单条操作+循环和成批量操作的时间消耗

    %%time
# 单条循环处理，慢
for i in range(1000):
    tokenizer(sen)

'''
CPU times: total: 172 ms
Wall time: 242 ms
'''

    %%time
# 成 batch 批量计算，快
tokenizer([sen] * 1000)

'''
CPU times: total: 78.1 ms
Wall time: 27.9 ms
'''

2. Fast/Slow Tokenizer

  • Transformer 库提供了两种 tokenizer

    1. FastTokenizer: 基于 Rust 实现，速度快，可以提供更多附加信息，类型名有后缀 Fast
    2. SlowTokenizer: 基于 python 实现，速度慢

  • 直接创建的 Tokenizer，如果存在 Fast 类型，则默认都是 Fast 类型

    sen = "快慢Tokenizer测试"
fast_tokenizer = AutoTokenizer.from_pretrained("uer/roberta-base-finetuned-dianping-chinese")
fast_tokenizer # 类型名有后缀 Fast

    BertTokenizerFast(name_or_path='uer/roberta-base-finetuned-dianping-chinese', vocab_size=21128, model_max_length=1000000000000000019884624838656, is_fast=True, padding_side='right', truncation_side='right', special_tokens={'unk_token': '[UNK]', 'sep_token': '[SEP]', 'pad_token': '[PAD]', 'cls_token': '[CLS]', 'mask_token': '[MASK]'}, clean_up_tokenization_spaces=True),  added_tokens_decoder={
	0: AddedToken("[PAD]", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	100: AddedToken("[UNK]", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	101: AddedToken("[CLS]", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	102: AddedToken("[SEP]", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	103: AddedToken("[MASK]", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
}

  • 构造 Tokenizer 时，可以通过传入 use_fast=False 强制构造 Slow Tokenizer

    # 设置 use_fast=False 来构造 SlowTokenizer
slow_tokenizer = AutoTokenizer.from_pretrained("uer/roberta-base-finetuned-dianping-chinese", use_fast=False)
slow_tokenizer # 类型名无后缀 Fast

    BertTokenizer(name_or_path='uer/roberta-base-finetuned-dianping-chinese', vocab_size=21128, model_max_length=1000000000000000019884624838656, is_fast=False, padding_side='right', truncation_side='right', special_tokens={'unk_token': '[UNK]', 'sep_token': '[SEP]', 'pad_token': '[PAD]', 'cls_token': '[CLS]', 'mask_token': '[MASK]'}, clean_up_tokenization_spaces=True),  added_tokens_decoder={
	0: AddedToken("[PAD]", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	100: AddedToken("[UNK]", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	101: AddedToken("[CLS]", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	102: AddedToken("[SEP]", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
	103: AddedToken("[MASK]", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),
}

    注意到 Tokenizer 对象类型名没有 Fast 后缀了。两种 Tokenizer 具有明显的速度差距

    %%time
fast_tokenizer([sen] * 10000)

'''
CPU times: total: 1.02 s
Wall time: 349 ms
'''

    %%time
slow_tokenizer([sen] * 10000)

'''
CPU times: total: 2.89 s
Wall time: 3.05 s
'''

  • Fast Tokenizer 有时会返回一些额外信息，例如有时候原始输入字符串中的英文不会按字母分词，而是按词根词缀分词，这时相应的 token 会对应到原始字符串中的一个索引区域，Fast Tokenizer 可以通过设置 return_offsets_mapping=True 获取 token 和原始索引区域的对应信息

    sen = "快慢Tokenizer测试"
inputs = fast_tokenizer(sen, return_offsets_mapping=True) # (只有 FastTokenizer 可以设置 return_offsets_mapping=True)
print(sen)                       # 打印原始字符串
print(inputs.word_ids())         # 打印各个 token 对应到原始字符串的 “词索引”，注意到原始字符串中 ”Tokenizer“ 这个词被拆成了4个token (只有 FastTokenizer 可以调用这个)
print(inputs['offset_mapping'])  # offset_mapping 指示了各个 token 对应的原始字符串索引区域

    快慢Tokenizer测试
[None, 0, 1, 2, 2, 2, 2, 3, 4, None]
[(0, 0), (0, 1), (1, 2), (2, 4), (4, 7), (7, 10), (10, 11), (11, 12), (12, 13), (0, 0)]

3. 加载特殊 Tokenizer

  • 有些开源模型的 Tokenizer 没有嵌入到 Transformers 库中，而是由作者在开源时于其远程仓库中提供，这种情况下 Tokenizer 的行为可能和 Transformers 库中其他 Tokenizer 的一般行为有所不同，直接加载这些模型会报错

    tokenizer = AutoTokenizer.from_pretrained("Skywork/Skywork-13B-base", trust_remote_code=False)
# ValueError: Loading Skywork/Skywork-13B-base requires you to execute the configuration file in that repo on your local machine. Make sure you have read the code there to avoid malicious use, then set the option `trust_remote_code=True` to remove this error.

    这时，需要在 .from_pretrained 方法中传入 trust_remote_code=True 对远程代码添加信任，才能正常下载目标 tokenizer

    tokenizer = AutoTokenizer.from_pretrained("Skywork/Skywork-13B-base", trust_remote_code=True)
tokenizer

    You are using the legacy behaviour of the <class 'transformers_modules.Skywork.Skywork-13B-base.bc35915066fbbf15b77a1a4a74e9b574ab167816.tokenization_skywork.SkyworkTokenizer'>. This means that tokens that come after special tokens will not be properly handled. 
SkyworkTokenizer(name_or_path='Skywork/Skywork-13B-base', vocab_size=65519, model_max_length=1000000000000000019884624838656, is_fast=False, padding_side='right', truncation_side='right', special_tokens={'bos_token': '<s>', 'eos_token': '</s>', 'unk_token': '<unk>'}, clean_up_tokenization_spaces=False),  added_tokens_decoder={
	0: AddedToken("<unk>", rstrip=False, lstrip=False, single_word=False, normalized=True, special=True),
	1: AddedToken("<s>", rstrip=False, lstrip=False, single_word=False, normalized=True, special=True),
	2: AddedToken("</s>", rstrip=False, lstrip=False, single_word=False, normalized=True, special=True),
}

  • 下载之后，可以用前文 1.1 节方法将其保存到本地

云端FFF
关注
  • 22
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
hugging face 使用教程———快速入门
TigerZ*的博客
07-24 810
本篇存在的意义是快速介绍hugging face使用，梳理主要部件，梳理易混淆概念。原因是：目前hugging face的使用，官方放在了3个地方（参考链接部分）：使用文档、NLP教程、Transformers git的readme 文件，很多重叠内容比较浪费时间，很容易看懵。等大家有了主要概念再去看需要具体看某个函数或功能。
Hugging face Transformers（2）—— Pipeline
佚失的诗篇
07-06 1110
本文介绍 Hugging face Transformers 库中 Pipeline 的基础用法，它可以帮我们快速调用预训练模型完成各类任务
一起学Hugging Face Transformers（3） - Hugging Face 加载模型和Tokenizer
一起来研究langchain和langchain-chatchat
06-27 1012
Hugging Face提供了一个强大的Transformers库，方便用户加载和使用预训练的自然语言处理模型及其相应的Tokenizer。本文将介绍如何加载预训练模型和Tokenizer，使用AutoModel和AutoTokenizer，以及了解不同模型的输入和输出格式，并举两个具体的例子进行说明。本文介绍了如何使用Hugging Face的Transformers库加载预训练模型和Tokenizer，使用AutoModel和AutoTokenizer类，以及不同模型的输入和输出格式。
Hugging face Transformers（4）—— Model
佚失的诗篇
07-09 369
本文介绍 Hugging face transformers 库中 model 组件的用法
使用 Hugging Face Transformers 库实现“代码生成和理解”功能
一起来研究langchain和langchain-chatchat
07-23 905
近年来，深度学习在自然语言处理（NLP）领域取得了显著进展，特别是使用 Transformers 架构的模型，如 BERT、GPT 等。Hugging Face 的 Transformers 库为研究人员和开发人员提供了一个强大且易于使用的工具包，使得实现复杂的 NLP 任务变得更加简单。在这篇文章中，我们将探讨如何使用 Hugging Face Transformers 库实现“代码生成和理解”功能。
Hugging Face Transformers模型如何使用
zhangzhechun的专栏
03-01 677
上面代码的输出是一个PyTorch张量，表示输入文本的预测分类结果。在这个示例中，由于我们只输入了一条文本，因此输出张量只有一个元素，表示这个文本的分类结果。具体来说，输出张量的值是一个数字，表示模型预测的文本类别，你可以根据你的具体任务和模型设置不同的类别标签。如果你的任务是二分类任务，那么输出值为0表示负类，输出值为1表示正类。接着，我们将输入文本编码为Bert模型的输入格式，并将其传入模型进行推理。你可以使用相似的方法来加载和使用这些模型，只需要将Bert相关的类和函数替换为相应的类和函数即可。
一起学Hugging Face Transformers（8）- 使用Transformers 库制作一个简易问答系统
一起来研究langchain和langchain-chatchat
07-01 1014
问答系统是一种能够自动回答用户问题的人工智能应用，在许多领域具有重要的应用价值，如客户服务、教育和医疗等。Hugging Face Transformers 库是一个强大的工具，它提供了许多预训练的自然语言处理模型，简化了构建问答系统的过程。本文将介绍如何使用 Hugging Face Transformers 库创建一个问答系统。本文介绍了如何使用 Hugging Face Transformers 库构建一个简单的问答系统。从环境准备、数据处理、模型选择到系统部署，涵盖了问答系统开发的各个方面。
hugging face 官方文档——datasets、optimizer
热门推荐
qq_56591814的博客
10-08 1万+
文章目录一、Load dataset1.1 Hugging Face Hub1.2 本地和远程文件1.2.1 CSV1.2.2 JSON1.2.3 text1.2.4 Parquet1.2.5 内存数据（python字典和DataFrame）1.2.6 Offline离线（见原文）1.3 切片拆分（Slice splits）1.4 Troubleshooting故障排除1.4.1手动下载1.4.2 Specify features指定功能1.5 加载自定义或本地metric1.5.2 Load config
Hugging face Transformers（1）—— 基础知识
佚失的诗篇
07-06 1027
Hugging face transformers 库简单介绍
使用Hugging Face Transformers库的示例代码，展示不同任务和大预言模型的用法.txt
08-16
### 使用Hugging Face Transformers库处理不同NLP任务的知识点 #### 一、文本分类任务（使用BERT模型） **1.1 概述** 文本分类是自然语言处理领域的一个经典问题，涉及将文本分配到预定义类别中。BERT...
Transformer大模型实战 Hugging Face的Transformers 库
光剑书架上的书
06-25 329
1.背景介绍 在自然语言处理（NLP）领域，Transformer模型已经成为了一种标准的架构。自从2017年由Google首次提出以来，Transformer模型以其独特的自注意力机制（Self-Attention Mechanism）和并行处理的优势，逐渐在各种NLP任务中取得了显著的成果。然而，Transformer模型的实现和优化并非易事，需要
第三章：AI大模型的主要技术框架3.3 Hugging Face Transformers3.3.1 Transformers简介与安装
光剑书架上的书
01-28 925
Transformers是一种基于自注意力机制（Self-Attention Mechanism）的深度学习模型，它在自然语言处理（NLP）领域取得了显著的成功。自2018年以来，Transformers已经成为了NLP领域的主流模型，取代了之前的循环神经网络（RNN）和长短时记忆网络（LSTM）。模型规模：随着计算能力的提高，未来的Transformer模型可能会变得更大、更复杂。训练数据：大量无标签数据的利用是Transformer模型成功的关键。未来可能会有更多的方法来利用无标签数据进行训练。
第三章：AI大模型的主要技术框架3.3 Hugging Face Transformers3.3.2 Transformers基本操作与实例
光剑书架上的书
01-19 376
更高效的模型：随着数据规模和计算能力的增加，需要开发更高效的模型，以满足实际应用中的性能要求。更好的解释性：为了提高模型的可解释性，需要开发更好的解释方法，以便更好地理解模型的内部工作原理。更广泛的应用：随着模型的发展，需要开发更广泛的应用，以便更好地满足不同领域的需求。更好的数据处理：随着数据规模的增加，需要开发更好的数据处理方法，以便更好地处理和存储大量数据。答案：要训练自定义模型，可以使用Hugging Face Transformers库提供的Trainer类。
实时计算：Apache Flink：Flink与Kafka集成实现事件驱动架构.docx
09-02
实时计算：Apache Flink：Flink与Kafka集成实现事件驱动架构.docx
移动软件开发实验五：高校新闻
09-02
移动软件开发实验五：高校新闻
分布式存储系统：Google Cloud Storage：GoogleCloudStorage架构解析.docx
09-02
分布式存储系统：Google Cloud Storage：GoogleCloudStorage架构解析.docx
基于现有explorer文件资源管理，实现跨平台告诉多标签页文件资源管理器，类似360文件管理器等，还处于起步阶段
09-02
基于现有explorer文件资源管理，实现跨平台告诉多标签页文件资源管理器，类似360文件管理器等，还处于起步阶段
关于进程之间的通信IPC，管道，信号的学习
最新发布
09-02
进程间通信（IPC）是操作系统中用于让不同进程之间相互通信的机制。管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。信号是在软件层次上对中断机制的一种模拟，是一种异步通信方式。该文章讲述了进程的通信通过管道与信号，以及扩展信号等实现进程间数据的交互。它们涵盖基础知识、代码示例和应用场景，适合初学者学习和参考。这些资源能够帮助你理解相关概念，并在实际开发中运用它们进行有效的进程间通信。
Hugging Face Transformers模型库中下载
07-22
要从Hugging Face Transformers模型库中下载模型，您可以使用`transformers`库中的`AutoModel`和`AutoTokenizer`来获取所需的模型和令牌化器。 首先，您需要安装`transformers`库，可以使用以下命令通过pip进行安装...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

云端FFF

所有博文免费阅读，求打赏鼓励~

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值