devbox
秋刀鱼在做梦
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

ROCm上运行预训练BERT_tensorflow rocm

作者：秋刀鱼在做梦 | 2024-07-06 20:29:54

赞

踩

tensorflow rocm

14.10. 预训练BERT — 动手学深度学习 2.0.0 documentation (d2l.ai)

下载数据集

在d2l-zh/pytorch/data目录解压：

  1. ~/d2l-zh/pytorch/data$ unzip wikitext-2-v1.zip 
  2. Archive:  wikitext-2-v1.zip
  3.    creating: wikitext-2/
  4.   inflating: wikitext-2/wiki.test.tokens  
  5.   inflating: wikitext-2/wiki.valid.tokens  
  6.   inflating: wikitext-2/wiki.train.tokens

代码

  1. import torch
  2. from torch import nn
  3. from d2l import torch as d2l
  4.  
  5. batch_size, max_len = 512, 64
  6. train_iter, vocab = d2l.load_data_wiki(batch_size, max_len)
  7.  
  8. net = d2l.BERTModel(len(vocab), num_hiddens=128, norm_shape=[128],
  9.                     ffn_num_input=128, ffn_num_hiddens=256, num_heads=2,
  10.                     num_layers=2, dropout=0.2, key_size=128, query_size=128,
  11.                     value_size=128, hid_in_features=128, mlm_in_features=128,
  12.                     nsp_in_features=128)
  13. devices = d2l.try_all_gpus()
  14. loss = nn.CrossEntropyLoss()
  15.  
  16. #@save
  17. def _get_batch_loss_bert(net, loss, vocab_size, tokens_X,
  18.                          segments_X, valid_lens_x,
  19.                          pred_positions_X, mlm_weights_X,
  20.                          mlm_Y, nsp_y):
  21.     # 前向传播
  22.     _, mlm_Y_hat, nsp_Y_hat = net(tokens_X, segments_X,
  23.                                   valid_lens_x.reshape(-1),
  24.                                   pred_positions_X)
  25.     # 计算遮蔽语言模型损失
  26.     mlm_l = loss(mlm_Y_hat.reshape(-1, vocab_size), mlm_Y.reshape(-1)) *\
  27.     mlm_weights_X.reshape(-1, 1)
  28.     mlm_l = mlm_l.sum() / (mlm_weights_X.sum() + 1e-8)
  29.     # 计算下一句子预测任务的损失
  30.     nsp_l = loss(nsp_Y_hat, nsp_y)
  31.     l = mlm_l + nsp_l
  32.     return mlm_l, nsp_l, l
  33. def train_bert(train_iter, net, loss, vocab_size, devices, num_steps):
  34.     net = nn.DataParallel(net, device_ids=devices).to(devices[0])
  35.     trainer = torch.optim.Adam(net.parameters(), lr=0.01)
  36.     step, timer = 0, d2l.Timer()
  37.     animator = d2l.Animator(xlabel='step', ylabel='loss',
  38.                             xlim=[1, num_steps], legend=['mlm', 'nsp'])
  39.     # 遮蔽语言模型损失的和，下一句预测任务损失的和，句子对的数量，计数
  40.     metric = d2l.Accumulator(4)
  41.     num_steps_reached = False
  42.     while step < num_steps and not num_steps_reached:
  43.         for tokens_X, segments_X, valid_lens_x, pred_positions_X,\
  44.             mlm_weights_X, mlm_Y, nsp_y in train_iter:
  45.             tokens_X = tokens_X.to(devices[0])
  46.             segments_X = segments_X.to(devices[0])
  47.             valid_lens_x = valid_lens_x.to(devices[0])
  48.             pred_positions_X = pred_positions_X.to(devices[0])
  49.             mlm_weights_X = mlm_weights_X.to(devices[0])
  50.             mlm_Y, nsp_y = mlm_Y.to(devices[0]), nsp_y.to(devices[0])
  51.             trainer.zero_grad()
  52.             timer.start()
  53.             mlm_l, nsp_l, l = _get_batch_loss_bert(
  54.                 net, loss, vocab_size, tokens_X, segments_X, valid_lens_x,
  55.                 pred_positions_X, mlm_weights_X, mlm_Y, nsp_y)
  56.             l.backward()
  57.             trainer.step()
  58.             metric.add(mlm_l, nsp_l, tokens_X.shape[0], 1)
  59.             timer.stop()
  60.             animator.add(step + 1,
  61.                          (metric[0] / metric[3], metric[1] / metric[3]))
  62.             step += 1
  63.             if step == num_steps:
  64.                 num_steps_reached = True
  65.                 break
  66.  
  67.     print(f'MLM loss {metric[0] / metric[3]:.3f}, '
  68.           f'NSP loss {metric[1] / metric[3]:.3f}')
  69.     print(f'{metric[2] / timer.sum():.1f} sentence pairs/sec on '
  70.           f'{str(devices)}')
  71.  
  72. train_bert(train_iter, net, loss, len(vocab), devices, 50)
  73.  
  74. def get_bert_encoding(net, tokens_a, tokens_b=None):
  75.     tokens, segments = d2l.get_tokens_and_segments(tokens_a, tokens_b)
  76.     token_ids = torch.tensor(vocab[tokens], device=devices[0]).unsqueeze(0)
  77.     segments = torch.tensor(segments, device=devices[0]).unsqueeze(0)
  78.     valid_len = torch.tensor(len(tokens), device=devices[0]).unsqueeze(0)
  79.     encoded_X, _, _ = net(token_ids, segments, valid_len)
  80.     return encoded_X
  81.  
  82. tokens_a = ['a', 'crane', 'is', 'flying']
  83. encoded_text = get_bert_encoding(net, tokens_a)
  84. # 词元：'<cls>','a','crane','is','flying','<sep>'
  85. encoded_text_cls = encoded_text[:, 0, :]
  86. encoded_text_crane = encoded_text[:, 2, :]
  87. encoded_text.shape, encoded_text_cls.shape, encoded_text_crane[0][:3]
  88.  
  89. tokens_a, tokens_b = ['a', 'crane', 'driver', 'came'], ['he', 'just', 'left']
  90. encoded_pair = get_bert_encoding(net, tokens_a, tokens_b)
  91. # 词元：'<cls>','a','crane','driver','came','<sep>','he','just',
  92. # 'left','<sep>'
  93. encoded_pair_cls = encoded_pair[:, 0, :]
  94. encoded_pair_crane = encoded_pair[:, 2, :]
  95. encoded_pair.shape, encoded_pair_cls.shape, encoded_pair_crane[0][:3]

代码解析

这个代码实现了基于Transformers模型业务的BERT（Bidirectional Encoder Representations from Transformers）的训练，以及在预训练过程中如何将BERT模型应用于两个NLP任务：遮蔽语言模型（Masked Language Model，MLM）和下一个句子预测（Next Sentence Prediction，NSP）。具体来说，它进行了以下步骤：
1. 加载数据集:

train_iter, vocab = d2l.load_data_wiki(batch_size, max_len)

   这行代码将会加载一个预处理过的维基百科数据集作为BERT的训练数据，每个批次的大小为512，最大长度为64个词元。
2. 创建BERT模型:

   net = d2l.BERTModel(len(vocab), ...)

   这里定义了一个BERT模型实例，其中包含有几种参数配置：词汇表大小、隐藏特征表示的维数、前馈神经网络层的参数等。
3. 设定损失函数和训练设备:
   - 损失函数使用了交叉熵损失。
   - 训练设备可以是GPU（如果可用）。
4. 定义BERT的批量损失计算函数`_get_batch_loss_bert`:
   计算给定批次数据的损失值，包括遮蔽语言模型损失和下一个句子预测损失。
5. 定义BERT的训练函数`train_bert`:
   设置BERT模型训练的相关参数和流程。
6. 执行训练:

   train_bert(train_iter, net, loss, len(vocab), devices, 50)

   运行训练函数，进行50步训练。
7. 用`get_bert_encoding`函数获得BERT模型编码的词元表示:
   函数接受一对句子（tokens_a和tokens_b），对它们进行编码，并返回编码后的词元表示。如果只有一个句子，tokens_b=None，默认tokens_b不提供。
8. 最后，通过编码两个示例句子，展示如何使用BERT模型来获取词元的嵌入表示。
注意，完整的代码实现了从数据准备、模型构建、训练到获取嵌入表示的整个过程。在实际使用时需要对应相应的数据集、网络参数和训练步骤进行适当的设置。此外，由"#<save>"标记的部分，是保存函数定义的提示，便于以后的复用。注意，该代码块可能需要根据实际环境和数据集导入额外的包和模块。

要在ROCm上运行预训练的BERT模型，您需要确保您的系统已经安装了支持ROCm的TensorFlow版本，并且已经正确配置了相关的环境。以下是一些关键步骤和注意事项：

  1. 安装Anaconda：首先，您需要在您的Linux系统上安装Anaconda，这是一个用于科学计算的Python发行版，它包含了运行BERT所需的许多库和工具。
  2. 安装TensorFlow：在ROCm上运行BERT需要使用TensorFlow的特定版本，即支持ROCm的版本。您可以从TensorFlow官方网站或者通过其他渠道获取适合ROCm的TensorFlow版本。
  3. 硬件配置：确保您的硬件配置满足运行BERT的要求。一般来说，需要有足够的GPU内存和计算能力。例如，有案例使用了配置为4*V100 (16G)，8核CPU，128G内存的硬件配置。
  4. 数据准备：根据您的NLP任务需求，准备或收集相应的训练数据。如果是特定的领域，如金融领域，您可能需要金融新闻、研究报告等数据。
  5. 模型调整：由于BERT是一个大规模的模型，您可能需要根据实际情况对模型进行调整，比如调整模型的大小、学习率等参数，以适应您的硬件条件和训练数据。
  6. 性能优化：在预训练过程中，您可能需要对性能进行优化，这包括使用混合精度训练、优化器选择等技术来提高训练效率和速度。
  7. 训练和评估：最后，您需要实际运行预训练过程，并在完成后对模型进行评估和调优，以确保其在您的特定任务上能够达到最佳性能。

请注意，上述步骤是一个大致的指南，具体操作可能需要根据您的实际情况和需求进行调整。此外，由于ROCm和BERT都是不断发展的技术，建议您查阅最新的官方文档和社区讨论，以获取最准确的安装和运行指南。

在ROCm（AMD的开源GPU加速计算平台）上运行预训练的BERT模型，通常涉及以下几个步骤：

  1. 安装ROCm：首先，你需要在你的AMD GPU支持的机器上安装ROCm。这包括安装驱动程序、运行时库、编译器（如HIP）等。确保你按照ROCm的官方文档进行了正确的安装和配置。
  2. 选择深度学习框架：选择一个支持ROCm的深度学习框架，如PyTorch或TensorFlow。这些框架提供了在GPU上运行深度学习模型的接口。你需要安装这些框架的ROCm版本。
  3. 下载预训练的BERT模型：从可靠的来源（如Hugging Face的Transformers库）下载预训练的BERT模型。确保你选择了与你的深度学习框架兼容的模型版本。
  4. 加载预训练的BERT模型：使用你选择的深度学习框架加载预训练的BERT模型。这通常涉及调用框架提供的特定函数或API来加载模型的权重和配置。
  5. 准备数据和预处理：准备你要用于自然语言处理任务的数据，并进行必要的预处理，如分词、编码等。确保你的数据格式与BERT模型的输入要求相匹配。
  6. 在ROCm上运行BERT模型：将你的数据和BERT模型传递给深度学习框架，并指定使用ROCm作为计算后端。这通常涉及设置环境变量或调用框架的特定函数来指定GPU加速。然后，你可以运行你的自然语言处理任务，并观察BERT模型在ROCm上的性能。

请注意，具体的实现细节可能会因你使用的深度学习框架和BERT模型版本而有所不同。因此，建议参考你选择的框架和模型的官方文档以获取更详细的指导和示例代码。

另外，由于ROCm是AMD的开源项目，其社区支持和资源可能不如NVIDIA的CUDA生态系统丰富。因此，在使用ROCm时可能会遇到一些挑战和限制。如果你遇到任何问题或困难，建议查阅相关的论坛、社区和文档以获取帮助。

找到了第 1 篇资料：AMD显卡配置深度学习环境（ROCm-pytorch） - 知乎

找到了第 2 篇资料：无需配环境，让你跟显卡唠唠嗑：AMD ROCm大语言模型 ...

找到了第 3 篇资料：面向中文的BERT预训练模型 - 知乎

找到了第 4 篇资料：BERT模型从训练到部署全流程_部署bert模型-CSDN博客

找到了第 5 篇资料：ROCm上运行深度卷积神经网络（AlexNet）-CSDN博客

找到了第 6 篇资料：AMD ROCM有没有明显的坑？ - 电脑讨论(新) - Chiphell ...

找到了第 7 篇资料：Posts tagged BERT — ROCm Blogs

找到了第 8 篇资料：ROCm 6.0.0 Release · ROCm ROCm · Discussion #2729

找到了第 9 篇资料：零基础用 Bert 训练并部署文本分类模型 - 知乎

找到了第 10 篇资料：深度解析BERT：从理论到Pytorch实战-腾讯云开发者社区-腾讯云

找到了第 11 篇资料：BERT模型：从训练到部署的完整指南-百度开发者中心

找到了第 12 篇资料：BERT简单使用：从预训练到部署的完整指南-百度开发者中心

在ROCm上运行预训练的BERT模型主要涉及以下几个步骤：

  1. 安装ROCm环境：确保你的系统已经安装了ROCm，包括所需的内核驱动、ROCm平台和相关的依赖库。根据 22，可以通过 amdgpu-install 命令来安装ROCm环境。

  2. 安装支持ROCm的深度学习框架：选择一个与ROCm兼容的深度学习框架，比如PyTorch。根据 22，建议使用AMD提供的Docker镜像来安装PyTorch，这样可以确保与ROCm的兼容性。

  3. 获取BERT预训练模型：你可以从Hugging Face的模型库或其他资源获取预训练的BERT模型。根据 24，有多种中文BERT预训练模型可供选择。

  4. 转换模型格式：如果BERT模型不是为ROCm优化的格式，你可能需要将其转换为ROCm兼容的格式。这可能涉及到将模型权重从一种格式转换为另一种格式，比如从TensorFlow的.ckpt转换为ONNX或直接支持ROCm的PyTorch模型格式。

  5. 在ROCm上运行BERT模型：加载模型并在ROCm加速的GPU上运行推理或进一步的训练。根据 23，可以使用专为大型语言模型设计的部署工具LM Studio，它支持ROCm加速。

  6. 性能优化：利用ROCm提供的性能分析工具，如rocprof、roctracer等，来分析和优化模型的性能。

请注意，由于硬件和软件的快速发展，具体的安装和配置步骤可能会随着时间而变化，因此建议查阅最新的ROCm和相关深度学习框架的官方文档。此外，由于ROCm是一个相对较新的平台，社区支持和资源可能没有像CUDA那样丰富，因此在ROCm上进行开发可能需要更多的实验和调试。2627

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/秋刀鱼在做梦/article/detail/793919
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号