【古诗生成AI实战】之四——模型包装器与模型的训练

  在上一篇博客中，我们已经利用任务加载器task成功地从数据集文件中加载了文本数据，并通过预处理器processor构建了词典和编码器。在这一过程中，我们还完成了词向量的提取。

  接下来的步骤涉及到定义模型、加载数据，并开始训练过程。

  为了确保项目代码能够快速切换到不同的模型，并且能够有效地支持transformers库中的预训练模型，我们不仅仅是定义模型那么简单。为此，我们采取了进一步的措施：在模型外面再套上一个额外的层，我称之为模型包装器NNModelWrapper。此外，为了提高配置的灵活性和可维护性，我们将所有的配置项（如批量大小、数据集地址、训练周期数、学习率等）抽取出来，统一放置在一个名为WrapperConfig的配置容器中。通过这种方式，我们就可以避免直接在代码中修改配置参数，而是通过更改配置文件来实现，从而使得整个项目更加模块化和易于管理。

  本章内容属于模型训练阶段，将分别介绍包装器配置WrapperConfig、模型包装器NNModelWrapper和模型Model。

在这里插入图片描述

[1] 包装器配置WrapperConfig

  我们把配置全部放在yaml文件里，然后读取里面的配置，赋值给WrapperConfig类。定义如下：

class WrapperConfig(object):
    """A configuration for a :class:`NNModelWrapper`."""

    def __init__(
            self,
            tokenizer,
            max_seq_len: int,
            vocab_num: int,
            word2vec_path: str,
            batch_size: int = 1,
            epoch_num: int = 1,
            learning_rate: float = 0.001
    ):
        self.tokenizer = tokenizer
        self.max_seq_len = max_seq_len
        self.batch_size = batch_size
        self.epoch_num = epoch_num
        self.learning_rate = learning_rate
        self.word2vec_path = word2vec_path
        self.vocab_num = vocab_num

   WrapperConfig 类用于配置神经网络模型包装器（NNModelWrapper）。类的构造函数接受多个参数来初始化配置：

  tokenizer: 分词器对象，用于文本处理或文本转换为模型可理解的格式。其实就是预处理器processor提供的tokenizer。

  max_seq_len (int): 模型可以处理的最大序列长度。

  vocab_num (int): 词汇表的大小。

  word2vec_path (str):预训练的词向量模型的文件路径。即上文提取的词向量。

  batch_size (int): 每个批次处理的数据样本数量。

  epoch_num (int): 训练轮次。

  learning_rate (float): 学习率。

[2] 模型包装器NNModelWrapper

  模型包装器NNModelWrapper接受2个参数，一个是包装器配置WrapperConfig，另外一个是自定义模型Model。代码如下：

class NNModelWrapper:
    """A wrapper around a Transformer-based language model."""

    def __init__(self, config: WrapperConfig, model):
        """Create a new wrapper from the given config."""
        self.config = config
        self.model = model(self.config)

    def generate_dataset(self, data, labeled=True):
        """Generate a dataset from the given examples."""
        features = self._convert_examples_to_features(data)

        feature_dict = {
            'input_ids': torch.tensor([f.input_ids for f in features], dtype=torch.long),
            'labels': torch.tensor([f.labels for f in features], dtype=torch.long),
        }

        if not labeled:
            del feature_dict['labels']

        return DictDataset(**feature_dict)

    def _convert_examples_to_features(self, examples) -> List[InputFeatures]:
        """Convert a set of examples into a list of input features."""
        features = []
        for (ex_index, example) in tqdm(enumerate(examples)):
            if ex_index % 5000 == 0:
                logging.info("Writing example {}".format(ex_index))
            input_features = self.get_input_features(example)
            features.append(input_features)
        # logging.info(f"最终数据构造形式：{features[0]}")
        return features

    def get_input_features(self, example) -> InputFeatures:
        """Convert the given example into a set of input features"""
        text = example.text
        input_ids = self.config.tokenizer(text)
        labels = np.copy(input_ids)
        labels[:-1] = input_ids[1:]

        assert len(input_ids) == self.config.max_seq_len

        return InputFeatures(input_ids=input_ids, attention_mask=None, token_type_ids=None, labels=labels)

   NNModelWrapper 类是围绕一个神经网络语言模型的封装器，提供了模型的初始化和数据处理的方法。

  · 类初始化 (init):
  config: 接收一个 WrapperConfig 类的实例，包含模型的配置信息。
  model: 接收一个模型构造函数，该函数使用配置信息来初始化模型。

  · 生成数据集 (generate_dataset):从给定的数据样本中生成一个数据集。首先把数据样本转换为特征（通过 _convert_examples_to_features 方法），然后根据这些特征创建一个 DictDataset 对象。如果数据未标记（labeled=False），则从特征字典中删除 labels 键。

  · 转换样本为特征 (_convert_examples_to_features):这是个私有方法，把数据样本转换为模型可以理解的输入特征。对于每个样本，使用 get_input_features 方法来生成输入特征。使用 tqdm 显示处理进度，并利用 logging 记录处理信息。

  · 获取输入特征 (get_input_features):此方法将单个数据样本转换为输入特征。首先获取文本内容，然后使用配置中的分词器（tokenizer）将文本转换为 input_ids。标签（labels）是 input_ids 的一个变体，其中每个元素都向右移动一个位置。用断言确保 input_ids 的长度与配置中的 max_seq_len 相等。

[3] 模型Model

  模型包装器NNModelWrapper里面的第二个参数Model才是我们真正的模型。

  在古诗生成AI任务中，RNN是比较适配任务的模型，我们定义的RNN模型如下：

class Model(nn.Module):

    def __init__(self, config):
        super(Model, self).__init__()

        V = config.vocab_num  # vocab_num
        E = 300  # embed_dim
        H = 256  # hidden_size

        embedding_pretrained = torch.tensor(np.load(config.word2vec_path)["embeddings"].astype('float32'))
        self.embedding = nn.Embedding.from_pretrained(embedding_pretrained, freeze=False)
        self.lstm = nn.LSTM(E, H, 1, bidirectional=False, batch_first=True, dropout=0.1)
        self.fc = nn.Linear(H, V)
        self.loss = nn.CrossEntropyLoss()

    def forward(self, input_ids, labels=None):
        embed = self.embedding(input_ids)  # [batch_size, seq_len, embed_dim]
        out, _ = self.lstm(embed)  # [batch_size, seq_len, hidden_size]
        logit = self.fc(out)  # [batch_size, seq_len, vocab_num]

        if labels is not None:
            loss = self.loss(logit.view(-1, logit.shape[-1]), labels.view(-1))
            return loss, logit
        else:
            return logit[None, :]

  在我们的模型中，特别值得一提的是嵌入层（embedding layer）。在初始化这一层时，我们使用的是之前提取出的词向量。这种做法有助于模型更好地理解和处理文本数据。

  此次我们定义的模型是一个基于RNN的结构，它包括三个主要部分：embedding层、lstm层和fc（全连接）层。

  在模型的前向传播（forward）过程中，输入input_ids的形状为[batch_size, seq_len]，即每个批次有多少文本，每个文本的序列长度是多少。输入数据首先通过嵌入层处理，输出的embed的形状为[batch_size, seq_len, embed_dim]，即每个单词都被转换成了对应的嵌入向量。接着，数据通过一个单层的lstm网络，得到输出out，最后经过全连接层fc，得到最终的概率分布logit。

  这个概率分布logit的含义是：对于每个批次中的文本，每个文本在序列的每个位置上，都有vocab_num个可能的词可以填入，而logit中存储的正是这些词的概率。为了生成文本，我们提取每个位置上概率最高的词的索引，然后根据这些索引在词典中查找对应的词。这就是我们通过模型运行文本生成得到的结果。

[4] 训练

  所有的工作都准备好了，下面我们正式开始模型的训练。

  对于神经网络的训练、验证、测试、优化等等操作，我采用了transformers的Trainer极大的简化了项目操作。

  第一步，加载yaml配置文件，读取所有配置项：

    with open('config.yaml', 'r', encoding='utf-8') as f:
        conf = yaml.load(f.read(),Loader=yaml.FullLoader)
        conf_train = conf['train']
        conf_sys = conf['sys']

  第二步，初始化任务加载器，加载数据集：

	Task = TASKS[conf_train['task_name']]()

    data = Task.get_train_examples(conf_train['dataset_url'])
    index = int(len(data) * conf_train['rate'])
    train_data, dev_data = data[:index], data[index:]

  第三步，初始化数据预处理器，并向外提供tokenizer：

	Processor = PROCESSORS[conf_train['task_name']](data, conf_train['max_seq_len'], conf_train['vocab_path'])
    tokenizer = lambda text: Processor.tokenizer(text)

  第四步，初始化模型包装配置：

	wrapper_config = WrapperConfig(
        tokenizer=tokenizer,
        max_seq_len=conf_train['max_seq_len'],
        batch_size=conf_train['batch_size'],
        epoch_num=conf_train['epoch_num'],
        learning_rate=conf_train['learning_rate'],
        word2vec_path=conf_train['word2vec_path'],
        vocab_num=len(Processor.vocab)
    )

  第五步，加载模型，初始化模型包装器：

	x = import_module(f'main.model.{conf_train["model_name"]}')
    wrapper = NNModelWrapper(wrapper_config, x.Model)

    print(f'模型有 {sum(p.numel() for p in wrapper.model.parameters() if p.requires_grad):,} 个训练参数')

  第六步，使用模型包装器生成数据集向量：

train_dataset = wrapper.generate_dataset(train_data)
    val_dataset = wrapper.generate_dataset(dev_data)

  第七步，创建训练器：

# 构建trainer
def create_trainer(wrapper, train_dataset, val_dataset):
    # 模型
    model = wrapper.model

    args = TrainingArguments(
        './checkpoints',  # 模型保存的输出目录
        save_strategy=IntervalStrategy.STEPS,  # 模型保存策略
        save_steps=50,  # 每n步保存一次模型  1步表示一个batch训练结束
        evaluation_strategy=IntervalStrategy.STEPS,
        eval_steps=50,
        overwrite_output_dir=True,  # 设置overwrite_output_dir参数为True，表示覆盖输出目录中已有的模型文件
        logging_dir='./logs',  # 可视化数据文件存储地址
        log_level="warning",
        logging_steps=50,  # 每n步保存一次评价指标  1步表示一个batch训练结束 | 还控制着控制台的打印频率 每n步打印一下评价指标 | n过大时，只会保存最后一次的评价指标
        disable_tqdm=True,  # 是否不显示数据训练进度条
        learning_rate=wrapper.config.learning_rate,
        per_device_train_batch_size=wrapper.config.batch_size,
        per_device_eval_batch_size=wrapper.config.batch_size,
        num_train_epochs=wrapper.config.epoch_num,
        dataloader_num_workers=2,  # 数据加载的子进程数
        weight_decay=0.01,
        save_total_limit=2,
        load_best_model_at_end=True
    )

    # 早停设置
    early_stopping = EarlyStoppingCallback(
        early_stopping_patience=3,  # 如果8次验证集性能没有提升，则停止训练
        early_stopping_threshold=0,  # 验证集的性能提高不到0时也停止训练
    )

    trainer = Trainer(
        model,
        args,
        train_dataset=train_dataset,
        eval_dataset=val_dataset,
        callbacks=[early_stopping],  # 添加EarlyStoppingCallback回调函数
    )
    return trainer
    
trainer = create_trainer(wrapper, train_dataset, val_dataset)

  第八步，开始训练并设置保存模型：

	trainer.train()
    trainer.save_model(conf_train['model_save_dir'] + conf_train['task_name'] + '/' + conf_train['model_name'])

  训练的整体代码如下：

# 构建trainer
def create_trainer(wrapper, train_dataset, val_dataset):
    # 模型
    model = wrapper.model

    args = TrainingArguments(
        './checkpoints',  # 模型保存的输出目录
        save_strategy=IntervalStrategy.STEPS,  # 模型保存策略
        save_steps=50,  # 每n步保存一次模型  1步表示一个batch训练结束
        evaluation_strategy=IntervalStrategy.STEPS,
        eval_steps=50,
        overwrite_output_dir=True,  # 设置overwrite_output_dir参数为True，表示覆盖输出目录中已有的模型文件
        logging_dir='./logs',  # 可视化数据文件存储地址
        log_level="warning",
        logging_steps=50,  # 每n步保存一次评价指标  1步表示一个batch训练结束 | 还控制着控制台的打印频率 每n步打印一下评价指标 | n过大时，只会保存最后一次的评价指标
        disable_tqdm=True,  # 是否不显示数据训练进度条
        learning_rate=wrapper.config.learning_rate,
        per_device_train_batch_size=wrapper.config.batch_size,
        per_device_eval_batch_size=wrapper.config.batch_size,
        num_train_epochs=wrapper.config.epoch_num,
        dataloader_num_workers=2,  # 数据加载的子进程数
        weight_decay=0.01,
        save_total_limit=2,
        load_best_model_at_end=True
    )

    # 早停设置
    early_stopping = EarlyStoppingCallback(
        early_stopping_patience=3,  # 如果8次验证集性能没有提升，则停止训练
        early_stopping_threshold=0,  # 验证集的性能提高不到0时也停止训练
    )

    trainer = Trainer(
        model,
        args,
        train_dataset=train_dataset,
        eval_dataset=val_dataset,
        callbacks=[early_stopping],  # 添加EarlyStoppingCallback回调函数
    )
    return trainer



def main():
    # ##
    # @通用配置
    # ##
    with open('config.yaml', 'r', encoding='utf-8') as f:
        conf = yaml.load(f.read(),Loader=yaml.FullLoader)
        conf_train = conf['train']
        conf_sys = conf['sys']

    # 系统设置初始化
    System(conf_sys).init_system()

    # 初始化任务加载器
    Task = TASKS[conf_train['task_name']]()

    data = Task.get_train_examples(conf_train['dataset_url'])
    index = int(len(data) * conf_train['rate'])
    train_data, dev_data = data[:index], data[index:]

    # 初始化数据预处理器
    Processor = PROCESSORS[conf_train['task_name']](data, conf_train['max_seq_len'], conf_train['vocab_path'])
    tokenizer = lambda text: Processor.tokenizer(text)

    # 初始化模型包装配置
    wrapper_config = WrapperConfig(
        tokenizer=tokenizer,
        max_seq_len=conf_train['max_seq_len'],
        batch_size=conf_train['batch_size'],
        epoch_num=conf_train['epoch_num'],
        learning_rate=conf_train['learning_rate'],
        word2vec_path=conf_train['word2vec_path'],
        vocab_num=len(Processor.vocab)
    )

    x = import_module(f'main.model.{conf_train["model_name"]}')
    wrapper = NNModelWrapper(wrapper_config, x.Model)

    print(f'模型有 {sum(p.numel() for p in wrapper.model.parameters() if p.requires_grad):,} 个训练参数')

    # 生成数据集
    train_dataset = wrapper.generate_dataset(train_data)
    val_dataset = wrapper.generate_dataset(dev_data)

    # 训练与保存
    trainer = create_trainer(wrapper, train_dataset, val_dataset)
    trainer.train()
    trainer.save_model(conf_train['model_save_dir'] + conf_train['task_name'] + '/' + conf_train['model_name'])

if __name__ == '__main__':
    main()

  运行之后，看到下面输出代表项目成功运行：

在这里插入图片描述

[5] 进行下一篇实战

  【古诗生成AI实战】之五——加载模型进行古诗生成

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/191377.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

kubernetes架构及核心组件简单介绍

kubernetes架构及核心组件简单介绍

目录 整体架构控制面kube-apiserver访问控制通知 kube-scheduler概述默认调度策略 kube-controller-manageretcd架构Raft协议日志复制 数据面kubeletkube-proxy 整体架构 集群架构图 控制面 控制面是kubernetes的核心组件，负责管理和控制集群的整体行为&#xf…
阅读更多...
前端入门（三）Vue生命周期、组件原理、脚手架、插槽插件、存储、组件事件、动画、跨域与代理

前端入门（三）Vue生命周期、组件原理、脚手架、插槽插件、存储、组件事件、动画、跨域与代理

文章目录 Vue生命周期Vue 组件化编程 - .vue文件非单文件组件组件的注意点组件嵌套Vue实例对象和VueComponent实例对象Js对象原型与原型链Vue与VueComponent的重要内置关系 应用单文件组件构建 Vue脚手架 - vue.cli项目文件结构组件相关高级属性引用名 - ref数据接入 - props混…
阅读更多...
云匣子 FastJson反序列化RCE漏洞复现

云匣子 FastJson反序列化RCE漏洞复现

0x01 产品简介 云匣子是租户连接云资源的安全管理工具，帮助云租户更加安全、精细的管理云上的虚拟机、数据库等资源。 云安宝结合多年的运维和安全实践，将云上的运维和安全有机结合，实现对运维过程的事前规划、事中控制和 事后审计。在此之上…
阅读更多...
Retrofit怎么返回一个JSON字符串？

Retrofit怎么返回一个JSON字符串？

项目用已经使用了 Retrofit，定义了接口方法，返回了 JSON 转换后的实体对象，炒鸡方便。但是总有意料之外的时候，比如我不需要返回实体对象，我要返回纯纯的 JSON 字符串，怎么办呢？ 先看源码 通过…
阅读更多...
数据里有{1,2,3,4,5,6,7,8,9}，请随机打乱顺序，生成一个新的数组

数据里有{1,2,3,4,5,6,7,8,9}，请随机打乱顺序，生成一个新的数组

问题：数据里有{1,2,3,4,5,6,7,8,9}，请随机打乱顺序，生成一个新的数组。 思路： 旧数组 nums，新数组 newNums 1、先创建一个新数组，用来存打乱数据后的元素，新旧数组的长度要一致 2、然后遍历数组…
阅读更多...
使用STM32与MFRC522 IC进行RFID卡的读取与识别（含代码）

使用STM32与MFRC522 IC进行RFID卡的读取与识别（含代码）

利用STM32与MFRC522 IC进行RFID卡的读取和识别，可以实现对RFID卡的读取和获取卡片标识信息。MFRC522 IC是一种高集成度的13.56MHz RFID芯片，常用于门禁系统、物流跟踪和智能支付等领域。下面将介绍如何使用STM32与MFRC522 IC进行RFID卡的读取和识别&…
阅读更多...
Mycat实现读写分离

Mycat实现读写分离

Mycat实现读写分离 Mycat支持MySQL主从复制状态绑定的读写分离机制。这里实现的也是基于MySQL主从复制的读写分离。 MySQL主从复制配置 首先要配置MySQL的主从复制，这里配置的是一主一次从。可以参考下面的文章。 https://blog.csdn.net/wsb_2526/article/detail…
阅读更多...
人工智能-优化算法和深度学习

人工智能-优化算法和深度学习

优化和深度学习 对于深度学习问题，我们通常会先定义损失函数。一旦我们有了损失函数，我们就可以使用优化算法来尝试最小化损失。在优化中，损失函数通常被称为优化问题的目标函数。按照传统惯例，大多数优化算法都关注的是最小化。…
阅读更多...
ElasticSearch02

ElasticSearch02

ElasticSearch客户端操作 ElasticSearch 版本：7.8 学习视频：尚硅谷 笔记：https://zgtsky.top/ 实际开发中，主要有三种方式可以作为elasticsearch服务的客户端： 第一种，使用elasticsearch提供的Restful接口…
阅读更多...
【数据库】缓冲区管理器结构，几种常用替换策略分析，pin钉住缓冲区块防止错误的替换，以及缓冲区管理带来的代价优化

【数据库】缓冲区管理器结构，几种常用替换策略分析，pin钉住缓冲区块防止错误的替换，以及缓冲区管理带来的代价优化

缓冲区管理 ​专栏内容： 手写数据库toadb 本专栏主要介绍如何从零开发，开发的步骤，以及开发过程中的涉及的原理，遇到的问题等，让大家能跟上并且可以一起开发，让每个需要的人成为参与者。 本专栏会定期更新&…
阅读更多...
微软发布了Orca 2，一对小型语言模型，它们的性能超越了体积更大的同类产品

微软发布了Orca 2，一对小型语言模型，它们的性能超越了体积更大的同类产品

尽管全球目睹了OpenAI的权力斗争和大规模辞职，但作为AI领域的长期支持者，微软并没有放慢自己的人工智能努力。今天，由萨提亚纳德拉领导的公司研究部门发布了Orca 2，这是一对小型语言模型，它们在零样本设置下对复杂推理…
阅读更多...
STK Components 二次开发-地面站传感器

STK Components 二次开发-地面站传感器

上一篇我们说了创建地面站，那么这次我们在地面站添加一些特效。 1. 创建地面站 var locationPoint1 new PointCartographic(m_earth, new Cartographic(Trig.DegreesToRadians(117.17066), Trig.DegreesToRadians(31.84056), 240.359)); m_facility new Platfor…
阅读更多...
计算机视觉面试题-01

计算机视觉面试题-01

计算机视觉面试通常涉及广泛的主题，包括图像处理、深度学习、目标检测、特征提取、图像分类等。以下是一些可能在计算机视觉面试中遇到的常见问题： 图像处理和计算机视觉基础 图像是如何表示的？ 图像在计算机中可以通过不同的表示方法&…
阅读更多...
以非常规思维去做一个嵌入式音视频开发项目！

以非常规思维去做一个嵌入式音视频开发项目！

前言： 大家好，在上周的文章里面，给大家介绍了一个音视频项目，本周继续来分享音视频项目，之前说过，如果你不知道做什么功能开发嘛，因为接触的少；我突然想到，可以去参考市面…
阅读更多...
JVM的小知识总结

JVM的小知识总结

加载时jvm做了这三件事： 1）通过一个类的全限定名来获取该类的二进制字节流 什么是全限定类名？ 就是类名全称，带包路径的用点隔开，例如: java.lang.String。 即全限定名 包名类型 非限定类名也叫短名，就…
阅读更多...
利用STM32和MFRC522 IC实现智能卡的读取和数据存储

利用STM32和MFRC522 IC实现智能卡的读取和数据存储

利用STM32微控制器和MFRC522 RFID读写器芯片，可以实现智能卡的读取和数据存储功能。智能卡是一种集成了RFID技术和存储芯片的卡片，它可以用于身份验证、门禁控制、支付系统等应用场景。下面将介绍如何使用STM32和MFRC522芯片进行智能卡的读取和数据存储&…
阅读更多...
【计算机视觉】【图像处理综合应用】路沿检测

【计算机视觉】【图像处理综合应用】路沿检测

实验内容：针对给定的视频，利用图像处理基本方法实现道路路沿的检测； 提示：可利用Hough变换进行线检测，融合路沿的结构信息实现路沿边界定位（图中红色的点位置）。 处理视频文件 处理视频文件的主…
阅读更多...
Nginx（资源压缩）

Nginx（资源压缩）

建立在动静分离的基础之上，如果一个静态资源的Size越小，那么自然传输速度会更快，同时也会更节省带宽，因此我们在部署项目时，也可以通过Nginx对于静态资源实现压缩传输，一方面可以节省带宽资源，第…
阅读更多...
GPT4测试 — 答题能力及文档处理能力

GPT4测试 — 答题能力及文档处理能力

创建gdp.txt文件（使用word 2013创建的文档测试了也可以，WPS建的不行） 上传文件，输入prompt: 请帮我答题，把那个正确答案的选项的字母序号填在（）中，并返回文件blabla… 给我一个文件…
阅读更多...
第二十三章 解析PR曲线、ROC曲线、AUC、AP(工具)

第二十三章 解析PR曲线、ROC曲线、AUC、AP(工具)

混淆矩阵Confusion Matrix 混淆矩阵定义 混淆矩阵是机器学习中总结分类模型预测结果的情形分析表，以矩阵形式将数据集中的记录按照真实的类别与分类模型预测的类别判断两个标准进行汇总。其中矩阵的行表示真实值，矩阵的列表示预测值，下面我…
阅读更多...
最新文章

Copyright @ 2022~2023