GPT2-Chinese 文本生成,训练AI写小说,AI写小说2

这篇具有很好参考价值的文章主要介绍了GPT2-Chinese 文本生成,训练AI写小说,AI写小说2。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

GPT2-Chinese 介绍

GPT-2 (Generative Pre-trained Transformer 2) 是由 OpenAI 开发的一种基于 Transformer 模型的自然语言处理(NLP)模型,旨在生成自然流畅的文本。它是一种无监督学习模型,其设计目标是能够理解人类语言的复杂性并模拟出自然的语言生成。

GPT-2 是目前最先进的自然语言处理模型之一,因为它具有大量的训练数据和强大的算法,可以生成自然流畅、准确的文本,其中文版本为GPT2-Chinese:使用wiki中文通用语料训练。

与其他基于神经网络的语言模型相比,GPT-2 具有许多独特的优点。首先,它采用了自监督学习的方式进行训练,使其能够处理多种语言和任务。其次,GPT-2 可以生成各种类型的文本,例如新闻、故事、对话和代码等。最后,GPT-2 模型使用了大量的预训练参数,使其具有强大的表现力和泛化能力。

GPT2-Chinese 版本是 GPT-2 模型的中文版本,也是基于 Transformer 模型构建的,具有相同的架构和训练技术。GPT2-Chinese 已经在多项中文 NLP 任务上取得了显著的成果,并被广泛应用于中文文本生成、问答、文本摘要和翻译等领域。

GPT-2 参数数量 1.5亿到1.75亿模型大小0.5GB到1.5GB

模型

每个参数占用的字节大小

模型大小

模型大小

层数

头数

GPT-1

4 个字节的 FP32 精度浮点数

117M

446MB

12

12

GPT-2

2 个字节的 FP16

1.5亿到1.75亿

0.5GB到1.5GB

48

16

GPT-3

2 个字节的 FP16

1.75万亿(17500亿)

350GB

175

96个头

下载代码

https://github.com/Morizeyao/GPT2-Chinese


 

在根目录(目录\GPT2-Chinese\)下建立文件夹data和model

\GPT2-Chinese\data

\GPT2-Chinese\model

把要训练的小说复制到train.json这里面

train.json(也即->?\GPT2-Chinese\data\train.json),需要注意的是,train.json编码格式严格为UTF-8,并且不带BOM头<-去头咱用的sublime。

 

vocab

  • vocab.txt:词汇表。默认的大小为13317,若需要使用自定义字典,需要将confog.json文件中的vocab_size字段设为相应的大小。也就是vocab.txt文件有多少行,多少个分词.
  • 把 vocab.txt 字典文件里的 [SEP] 行号减1,设置为 Config.json 配置文件  "bos_token_id": 1,和  "eos_token_id": 1,的值.减1是因为vocab是从0下标开始,而行下标是从1开始.我这里设置为1是因为我的 [SEP] 在vocab的第二行.

特殊 token 符号

[UNK]:表示未知标记(即,词汇表中没有的词);
[SEP]:表示句子分隔符;换行
[PAD]:表示填充标记,用于填充序列的长度;也就是无效符号。
pad_token_id默认为tokenizer.eos_token_id,这是特殊token [EOS]的位置。它被用来指示模型当前生成的句子已经结束,因此当我们想要生成一个开放式文本时,我们可以将pad_token_id设置为eos_token_id,以确保生成文本不会被提前结束。
[CLS]:表示分类标记,用于BERT模型的分类任务;文章之间添加CLS表示文章结束
[MASK]:表示掩码标记,用于BERT模型的掩码语言建模任务。文章开头添加MASK表示文章开始

 vocab 词汇表

在自然语言处理任务中,将文本转换成数字是非常重要的预处理步骤之一。这个过程叫做文本编码。传统的文本编码方法,如one-hot编码或词袋模型,通常会忽略单词之间的语义和上下文关系,因此不太适用于语义相似性计算、文本分类、问答系统等需要更深层次理解文本含义的任务。
通过词汇表 把一个字 、一个短语 、一个短句 转换成一个数字 ,形成了 数字 映射 成 文字,文字映射成 数字的过程。字典 词典 

model_config = transformers.modeling_gpt2.gpt2config.from_json_file(args.mod,pytorch,深度学习,pytorch,人工智能

 词汇表的大小会对训练模型的大小和复杂度产生影响。
在自然语言处理中,词汇表是所有可能的单词集合。如果词汇表很大,那么训练模型需要处理更多的单词和更多的单词组合,因此会增加模型的复杂度和大小。
此外,词汇表的大小还会影响模型的训练时间和资源消耗。一个包含更多单词的词汇表需要更多的内存和计算资源来存储和处理。
因此,为了训练一个高效且准确的自然语言处理模型,需要平衡词汇表大小和模型大小之间的关系,并考虑可用的计算资源和训练时间。

 安装依赖

transformers>=2.1.1
torch
numpy
tqdm
sklearn
keras
tb-nightly
future
thulac

 如果transformers>=4.2.1  要修改的改以下代码

transformers  报错 got_ver is None,重装numpy,
pip uninstall numpy
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple numpy
#model_config = transformers.modeling_gpt2.GPT2Config.from_json_file(args.model_config)
    model_config = transformers.models.gpt2.GPT2Config.from_json_file(args.model_config)
    if not args.pretrained_model:
        #model = transformers.modeling_gpt2.GPT2LMHeadModel(config=model_config)
        model = transformers.models.gpt2.GPT2LMHeadModel(config=model_config)
    else:
        #model = transformers.modeling_gpt2.GPT2LMHeadModel.from_pretrained(args.pretrained_model)
        model = transformers.models.gpt2.GPT2LMHeadModel(args.pretrained_model)
提示模块'transformers'没有属性'WarmupLinearSchedule'的异常
这是因为在新版本中WarmupLinearSchedule方法已经没有了,可以换为get_linear_schedule_with_warmup方法

    # scheduler = transformers.WarmupLinearSchedule(optimizer, warmup_steps=warmup_steps,
    #                                                       t_total=total_steps)
    scheduler = transformers.get_linear_schedule_with_warmup(optimizer, num_warmup_steps =warmup_steps,
                                                           num_training_steps =total_steps)

 Config.json 配置文件

{
  "_name_or_path": "model/",
  "activation_function": "gelu_new",
  "architectures": [
    "GPT2LMHeadModel"
  ],
  "attn_pdrop": 0.1,
  "bos_token_id": 1,
  "embd_pdrop": 0.1,
  "eos_token_id": 1,
  "initializer_range": 0.02,
  "layer_norm_epsilon": 1e-05,
  "model_type": "gpt2",
  "n_ctx": 512,
  "n_embd": 1024,
  "n_head": 16,
  "n_inner": null,
  "n_layer": 12,
  "n_positions": 512,
  "reorder_and_upcast_attn": false,
  "resid_pdrop": 0.1,
  "scale_attn_by_inverse_layer_idx": false,
  "scale_attn_weights": true,
  "summary_activation": null,
  "summary_first_dropout": 0.1,
  "summary_proj_to_labels": true,
  "summary_type": "cls_index",
  "summary_use_proj": true,
  "torch_dtype": "float16",
  "transformers_version": "4.26.1",
  "use_cache": true,
  "vocab_size": 47689
}

  Config.json 配置文件参数解释

"activation_function": "gelu_new": 激活函数,这里使用改进版的GELU函数
"attn_pdrop": 0.1: 注意力机制中的dropout概率,每个注意力机制的权重有10%的概率被置为0
"bos_token_id": 50256: 开始标记(Begin-Of-Sequence)的token ID,这里是50256
"embd_pdrop": 0.1: 输入嵌入层中的dropout概率,每个输入token的嵌入向量有10%的概率被置为0
"eos_token_id": 50256: 结束标记(End-Of-Sequence)的token ID,这里是50256
"initializer_range": 0.02: 初始化权重矩阵的范围,权重值在正负0.02之间均匀分布
"layer_norm_epsilon": 1e-05: Layer Normalization的epsilon值,防止分母为0
"model_type": "gpt2": 模型类型,这里是GPT-2
"n_ctx": 512: 输入的文本序列的最大长度,这里是512
"n_embd": 768: 输入嵌入层的维度,这里是768
"n_head": 12: Transformer中的多头注意力机制中头的数量,这里是12
"n_inner": null: Transformer中全连接层的隐层层数,这里是null表示使用默认值(4)
"n_layer": 10: Transformer中的层数,这里是10
"n_positions": 512: 输入的位置编码的维度,这里是512
"reorder_and_upcast_attn": false: 是否需要重新排序并升级注意力机制的权重矩阵,这里是false
"resid_pdrop": 0.1: 残差连接的dropout概率,每个残差连接的输出向量有10%的概率被置为0
"scale_attn_by_inverse_layer_idx": false: 是否根据层数来缩放注意力机制的权重矩阵,这里是false
"scale_attn_weights": true: 是否需要缩放注意力机制的权重矩阵,这里是true
"summary_activation": null: 摘要(Summary)层的激活函数,这里是null表示使用默认值(softmax)
"summary_first_dropout": 0.1: 摘要(Summary)层中第一个dropout的概率,这里是10%
"summary_proj_to_labels": true: 摘要(Summary)层是否需要将摘要结果投影到标签空间,这里是true
"summary_type": "cls_index": 摘要(Summary)的类型,这里是CLS池化层
"summary_use_proj": true: 摘要(Summary)层是否需要使用投影层,这里是true
"transformers_version": "4.22.1": 使用


训练材料处理流程

0.根据小说制作词汇表文件

import os
import jieba
from collections import Counter


def build_vocab(text_file, vocab_file, vocab_size, ignore_single=False):
    # 读取文本文件并进行分词
    '''
    text_file:要处理的文本文件路径。
    vocab_file:生成的词汇表文件路径。
    vocab_size:词汇表大小,即最多包含多少个单词。
     ignore_single 的布尔型参数,默认为 False。如果设置为 True,则不会将单个字添加到词汇表中
    '''
    # 读取文本文件并进行分词
    with open(text_file, 'r', encoding='utf-8') as f:
        text = f.read()
    words = jieba.lcut(text)

    # 统计词频
    counter = Counter(words)
    if ignore_single:
        counter = {word: freq for word, freq in counter.items() if len(word) > 1}
    sorted_words = sorted(counter.items(), key=lambda x: x[1], reverse=True)

    # 保存词汇表文件
    with open(vocab_file, 'w', encoding='utf-8') as f:
        for i, (word, freq) in enumerate(sorted_words):
            if i >= vocab_size:
                break
            f.write(word + '\n')


dir_path = os.path.dirname(os.path.abspath(__file__))  # 本脚本所在的目录路径,
novel_file_path = os.path.join(dir_path, "西游记.txt")
vocab_path = os.path.join(dir_path, "vocab.txt")
build_vocab(novel_file_path, vocab_path, 48000)

 

1.读取小说文件,平分成100份,100份后多余的部分舍弃.每份保存到一个文件

import os
from tqdm import tqdm

if __name__ == '__main__':
    dir_path = os.path.dirname(os.path.abspath(__file__))  # 本脚本所在的目录路径
    novel_file_path = os.path.join(dir_path, "西游记.txt")
    split_novel_path = os.path.join(dir_path, "split_novel")

    # 创建保存 tokenized 文件的目录
    if not os.path.exists(split_novel_path):
        os.mkdir(split_novel_path)

    with open(novel_file_path, 'r', encoding='utf8') as f:
        print('reading lines')
        single = f.read()

    len_single = len(single)
    num_pieces = 100
    for i in tqdm(range(num_pieces)):
        # 从 single 中截取一段长度为 len_single // num_pieces
        # 并进行分词
        sub_text = single[len_single // num_pieces * i: len_single // num_pieces * (i + 1)]
        seg_file_path = os.path.join(split_novel_path, f"split_novel_{i}.txt")
        with open(seg_file_path, 'w', encoding='utf8') as f:
            f.write(sub_text)

2.每份字符串用cut函数分词,单词之间用空格连接区分 ,然后把每份写到 word_segmentation文件夹内,每份名称word_segmentation_0.txt-word_segmentation_99.txt

'''
from vocab import Vocab

# 创建一个词汇表对象
vocab = Vocab('vocab.txt')

# 对输入文本进行分词
text = '我爱自然语言处理'
tokens = vocab.cut(text)
print(tokens) # ['我', '爱', '[UNK]', '[UNK]']

# 将单词列表编码成单词索引列表
token_ids = vocab.encode_tokens(tokens)
print(token_ids) # [143, 54, 0, 0]

# 将单词索引列表解码成单词列表
decoded_tokens = vocab.decode_tokens(token_ids)
print(decoded_tokens) # ['我', '爱', '[UNK]', '[UNK]']
'''



class Vocab:
    def __init__(self, vocab_file):
        """
        从给定的词汇表文件中构建一个词汇表对象,并将每个单词与其对应的索引建立映射关系。
        Args:
            vocab_file (str): 词汇表文件路径。
        """
        self.token2id = {}  # 词汇表中每个单词与其索引之间的映射(字典)
        self.id2token = {}  # 词汇表中每个索引与其对应的单词之间的映射(字典)

        # 读取词汇表文件,将每个单词映射到其索引
        with open(vocab_file, 'r', encoding='utf-8') as f:
            for i, line in enumerate(f):
                token = line.strip()  # 移除行尾的换行符并得到单词
                self.token2id[token] = i  # 将单词映射到其索引
                self.id2token[i] = token  # 将索引映射到其对应的单词
        self.num_tokens = len(self.token2id)  # 词汇表中单词的数量
        self.unknown_token = '[UNK]'  # 特殊的未知标记
        self.pad_token = '[PAD]'  # 用于填充序列的特殊标记(在这里仅用于编码)
        self.pad_token_id = self.token2id.get(self.pad_token, -1)  # 填充标记的索引

    def cut(self, input_str):
        """
        中文语句分词的算法  用python代码 cut函数 参数 词汇表文件 和 语句str
        词汇表文件 每行一个词语,

        1.词汇表字典的键为词汇,值为该词汇在词汇表中的行号-1,也即该词汇在词汇表中的索引位置。
        3.输入的中文语句,从左到右依次遍历每一个字符,以当前字符为起点尝试匹配一个词汇。具体匹配方式如下:

        a. 从当前字符开始,依次向后匹配,直到找到一个最长的词汇。如果该词汇存在于词典中,就将其作为一个分词结果,并将指针移动到该词汇的后面一个字符。如果该词汇不存在于词典中,则将当前字符作为一个单独的未知标记,同样将其作为一个分词结果,并将指针移动到下一个字符。
        b. 如果从当前字符开始,没有找到任何词汇,则将当前字符作为一个单独的未知标记,同样将其作为一个分词结果,并将指针移动到下一个字符。
        重复上述过程,直到遍历完整个输入的中文语句,得到所有的分词结果列表。
        """
        result = []
        i = 0
        while i < len(input_str):
            longest_word = input_str[i]
            for j in range(i + 1, len(input_str) + 1):
                if input_str[i:j] in self.token2id:
                    longest_word = input_str[i:j]
            result.append(longest_word)
            i += len(longest_word)
        return result


    def encode_tokens_strToint(self, tokens):
        """
        将给定的单词列表编码成对应的单词索引列表。
        如果一个单词在词汇表中没有出现,则将其替换为特殊的未知标记。
        Args:
            tokens (list): 待编码的单词列表。
        Returns:
            token_ids (list): 编码后的单词索引列表。
        """
        return [self.token2id.get(token, self.token2id[self.unknown_token]) for token in tokens]

    def decode_tokens_intTostr(self, token_ids):

        """
        将给定的单词索引列表解码成对应的单词列表。
        如果一个索引在词汇表中没有对应的单词,则将其替换为特殊的未知标记。
        Args:
            token_ids (list): 待解码的单词索引列表。
        Returns:
        tokens (list): 解码后的单词列表。
        """
        return [self.id2token.get(token_id, self.unknown_token) for token_id in token_ids]

import os
import threading
from multiprocessing import Process
from Vocab import Vocab


def process_file(i: int, content: str, vocab: Vocab, word_segmentation_path: str):
    # 进行分词并保存到文件
    seg = vocab.cut(content)
    file_path = os.path.join(word_segmentation_path, f"word_segmentation_{i}.txt")
    with open(file_path, "w", encoding="utf-8") as f:
        f.write(" ".join(seg))

    print(f"Thread-{threading.current_thread().ident} finished processing file-{i}")


def many_Process():
    dir_path = os.path.dirname(os.path.abspath(__file__))  # 本脚本所在的目录路径
    novel_file_path = os.path.join(dir_path, "西游记.txt")
    tokenized_data_path = os.path.join(dir_path, "tokenized")
    vocab_path = os.path.join(dir_path, "vocab.txt")
    word_segmentation_path = os.path.join(dir_path, "word_segmentation")
    split_novel_path = os.path.join(dir_path, "split_novel")

    # 创建保存结果的文件夹
    os.makedirs(word_segmentation_path, exist_ok=True)

    # 定义文件名和分割数
    num_splits = 100

    for i in range(num_splits):
        seg_file_path = os.path.join(split_novel_path, f"split_novel_{i}.txt")
        with open(seg_file_path, 'r', encoding='utf8') as f:
            content = f.read()
        # 创建Vocab实例
        vocab = Vocab(vocab_path)
        proc1 = Process(target=process_file, args=(i, content, vocab, word_segmentation_path))
        proc1.start()


if __name__ == '__main__':
    many_Process()

3.把分词文件转换为int数字文件

import os

def main():
    dir_path = os.path.dirname(os.path.abspath(__file__))  # 本脚本所在的目录路径
    novel_file_path = os.path.join(dir_path, "西游记.txt")
    tokenized_data_path = os.path.join(dir_path, "tokenized")
    vocab_path = os.path.join(dir_path, "vocab.txt")
    word_segmentation_path = os.path.join(dir_path, "word_segmentation")

    # 读取词汇表
    with open(vocab_path, "r", encoding="utf-8") as f:
        vocab = {}
        for i, line in enumerate(f):
            word = line.strip()
            vocab[word] = i

    # 读取分词文件并转换为token
    for i in range(100):
        seg_file_path = os.path.join(word_segmentation_path, f"word_segmentation_{i}.txt")
        token_file_path = os.path.join(tokenized_data_path, f"tokenized_train_{i}.txt")
        with open(seg_file_path, "r", encoding="utf-8") as f:
            with open(token_file_path, "w", encoding="utf-8") as fw:
                for line in f:
                    tokens = []
                    for word in line.strip().split():
                        if word in vocab:
                            tokens.append(str(vocab[word]))
                    if tokens:
                        fw.write(" ".join(tokens) + "\n")


if __name__ == '__main__':
    main()

5.调用训练脚本 train.py

import transformers
import torch
print(torch.cuda.current_device())
import os
import random
import argparse
import numpy as np
from torch.nn import DataParallel
from tqdm import tqdm
import datetime


def is_tokenizer(tokenized_data_path):
    if not os.path.exists(tokenized_data_path):
        return False

    # 获取目录下(包含子目录)的所有文件数
    file_nums = sum([len(files) for root, dirs, files in os.walk(tokenized_data_path)])
    if file_nums > 1:
        return True
    else:
        return False


def main():
    # char_to_int.run()
    parser = argparse.ArgumentParser()
    parser.add_argument('--device', default='0,1,2,3', type=str, required=False, help='设置使用哪些显卡')
    parser.add_argument('--model_config', default='./config.json', type=str, required=False,help='选择模型参数')
    parser.add_argument('--tokenizer_path', default='./newvocab.txt', type=str, required=False, help='选择词库')
    parser.add_argument('--tokenized_data_path', default='./tokenized/', type=str, required=False,help='tokenized语料存放位置')
    parser.add_argument('--raw', action='store_true', help='是否先做tokenize')
    parser.add_argument('--epochs', default=50000, type=int, required=False, help='训练循环')
    parser.add_argument('--batch_size', default=1, type=int, required=False, help='训练batch size')
    parser.add_argument('--lr', default=1.5e-4, type=float, required=False, help='学习率')
    parser.add_argument('--warmup_steps', default=2000, type=int, required=False, help='warm up步数')
    parser.add_argument('--log_step', default=1, type=int, required=False, help='多少步汇报一次loss')
    parser.add_argument('--stride', default=768, type=int, required=False, help='训练时取训练数据的窗口步长')
    parser.add_argument('--gradient_accumulation', default=1, type=int, required=False, help='梯度积累')
    parser.add_argument('--fp16', action='store_true', help='混合精度')
    parser.add_argument('--fp16_opt_level', default='O1', type=str, required=False)
    parser.add_argument('--max_grad_norm', default=1.0, type=float, required=False)
    parser.add_argument('--num_pieces', default=100, type=int, required=False, help='将训练语料分成多少份')
    parser.add_argument('--output_dir', default='model/', type=str, required=False, help='模型路径')
    parser.add_argument('--pretrained_model', default='', type=str, required=False, help='模型训练起点路径')
    parser.add_argument('--segment', action='store_true', help='中文以词为单位')
    args = parser.parse_args()
    print('args:\n' + args.__repr__())


    is_random_shuffle_data=False    # 是否打乱顺序进行训练

    if args.segment:
        from tokenizations import tokenization_bert_word_level as tokenization_bert
    else:
        from tokenizations import tokenization_bert

    os.environ["CUDA_VISIBLE_DEVICES"] = args.device  # 此处设置程序使用哪些显卡
    model_config = transformers.models.gpt2.GPT2Config.from_json_file(args.model_config)
    print('config:\n' + model_config.to_json_string())

    n_ctx = model_config.n_ctx
    full_tokenizer = tokenization_bert.BertTokenizer(vocab_file=args.tokenizer_path)
    full_tokenizer.max_len = 999999
    device = 'cuda' if torch.cuda.is_available() else 'cpu'

    print('using device:', device)


    tokenized_data_path = args.tokenized_data_path
    raw = is_tokenizer(tokenized_data_path)  # 选择是否从零开始构建数据集
    epochs = args.epochs
    batch_size = args.batch_size
    lr = args.lr
    warmup_steps = args.warmup_steps
    log_step = args.log_step
    stride = args.stride
    gradient_accumulation = args.gradient_accumulation
    fp16 = args.fp16  # 不支持半精度的显卡请勿打开
    fp16_opt_level = args.fp16_opt_level
    max_grad_norm = args.max_grad_norm
    num_pieces = args.num_pieces
    output_dir = args.output_dir

    if raw == False:
        print('building files')


    model_dir = args.output_dir
    config_file = os.path.join(model_dir, 'config.json')
    pytorch_model_file = os.path.join(model_dir, 'pytorch_model.bin')

    if os.path.isfile(config_file) and os.path.isfile(pytorch_model_file):
        print('模型文件存在,加载已训练过的模型,继续训练...')
        model = transformers.models.gpt2.GPT2LMHeadModel.from_pretrained(model_dir)
    else:
        print('模型文件不存在,创建新的模型,开始训练...')
        model = transformers.models.gpt2.GPT2LMHeadModel(config=model_config)

    model.train()
    model.to(device)
    print(model)
    multi_gpu = False
    full_len = 0
    print('calculating total steps')
    for i in tqdm(range(num_pieces)):
        with open(tokenized_data_path + 'tokenized_train_{}.txt'.format(i), 'r') as f:
            full_len += len([int(item) for item in f.read().strip().split()])
    total_steps = int(full_len / stride * epochs / batch_size / gradient_accumulation)
    print('total steps = {}'.format(total_steps))
    optimizer = transformers.AdamW(model.parameters(), lr=lr, correct_bias=True)
    scheduler = transformers.get_linear_schedule_with_warmup(optimizer, num_warmup_steps=warmup_steps,
                                                             num_training_steps=total_steps)

    steps_Count = 0
    if fp16:
        try:
            from apex import amp
        except ImportError:
            raise ImportError("Please install apex from https://www.github.com/nvidia/apex to use fp16 training.")
        model, optimizer = amp.initialize(model, optimizer, opt_level=fp16_opt_level)

    if torch.cuda.device_count() > 1:
        print("Let's use", torch.cuda.device_count(), "GPUs!")
        model = DataParallel(model)
        multi_gpu = True
    print('calculating total steps')
    for i in tqdm(range(num_pieces)):  # 迭代处理所有的 tokenized_train_{}.txt 文件
        with open(tokenized_data_path + 'tokenized_train_{}.txt'.format(i), 'r') as f:  # 打开文件
            full_len += len([int(item) for item in f.read().strip().split()])  # 统计文件中数字的数量
    total_steps = int(full_len / stride * epochs / batch_size / gradient_accumulation)  # 计算总共需要迭代的步数
    print('total steps = {}'.format(total_steps))  # 打印总共需要迭代的步数
    optimizer = transformers.AdamW(model.parameters(), lr=lr, correct_bias=True)  # 定义优化器
    scheduler = transformers.get_linear_schedule_with_warmup(optimizer, num_warmup_steps=warmup_steps,
                                                             num_training_steps=total_steps)  # 定义学习率调度器

    steps_Count = 0  # 初始化迭代步数
    if fp16:  # 判断是否使用半精度浮点数
        try:
            from apex import amp  # 尝试导入 apex 库
        except ImportError:
            raise ImportError("Please install apex from https://www.github.com/nvidia/apex to use fp16 training.")
        model, optimizer = amp.initialize(model, optimizer, opt_level=fp16_opt_level)  # 将模型和优化器转换成半精度浮点数

    if torch.cuda.device_count() > 1:  # 判断是否有多个 GPU
        print("Let's use", torch.cuda.device_count(), "GPUs!")
        model = DataParallel(model)  # 多 GPU 并行计算
        multi_gpu = True  # 标记启用了多 GPU
    print('starting training')  # 打印开始训练
    running_loss = 0  # 初始化损失值
    run_pice = 0  # 初始化处理的文件数量

    elapsed_minutes = 3  # 每过 20 分钟后 就会休息 3.5分钟.
    rest_minutes = 1.2
    start_time = datetime.datetime.now()

    for epoch in range(epochs):
        print('epoch {}'.format(epoch + 1))
        now = datetime.datetime.now()
        print('time: {}'.format(now))
        x = np.linspace(0, num_pieces - 1, num_pieces, dtype=np.int32)  # 生成0~num_pieces-1的等差数列
        if is_random_shuffle_data:
            random.shuffle(x)  # 打乱数列顺序
        piece_num = 0
        for i in x:  # 遍历每个文件
            with open(tokenized_data_path + 'tokenized_train_{}.txt'.format(i), 'r') as f:  # 打开tokenized_train_i.txt文件
                line = f.read().strip()  # 读取整个文件的内容,并移除字符串首尾的空格符
            tokens = line.split()  # 按照空格符分割字符串,得到单词列表
            tokens = [int(token) for token in tokens]  # 将单词列表中的元素转化为整型数值
            start_point = 0
            samples = []  # 存储数据样本的列表
            while start_point < len(tokens) - n_ctx:  # 循环采样数据样本,直到文本结束
                samples.append(tokens[start_point: start_point + n_ctx])  # 截取长度为n_ctx的数据样本,并加入列表
                start_point += stride  # 步长为stride
            if start_point < len(tokens):  # 如果剩下的单词数小于n_ctx
                samples.append(tokens[len(tokens) - n_ctx:])  # 将剩下的单词作为一个数据样本加入列表
            if is_random_shuffle_data:
                random.shuffle(samples)  # 打乱数据样本的顺序
            for step in range(len(samples) // batch_size):  # 将数据样本按batch_size分组,遍历每个batch
                #  准备数据  # 1. 获取输入的 batch
                batch = samples[step * batch_size: (step + 1) * batch_size]  # 获取当前batch的数据样本
                batch_labels = []  # 存储batch的标签
                batch_inputs = []  # 存储batch的输入
                for ids in batch:  # 遍历当前batch的数据样本
                    int_ids_for_labels = [int(x) for x in ids]  # 将数据样本中的每个单词转化为整型数值,得到标签序列
                    int_ids_for_inputs = [int(x) for x in ids]  # 将数据样本中的每个单词转化为整型数值,得到输入序列
                    batch_labels.append(int_ids_for_labels)  # 将标签序列加入batch_labels列表
                    batch_inputs.append(int_ids_for_inputs)  # 将输入序列加入batch_inputs列表
                batch_labels = torch.tensor(batch_labels).long().to(device)  # 将batch_labels转化为PyTorch的tensor,并移动到GPU上
                batch_inputs = torch.tensor(batch_inputs).long().to(device)  # 将batch_inputs转化为PyTorch的tensor,并移动到GPU上

                # 2. 正向传播
                outputs = model.forward(input_ids=batch_inputs, labels=batch_labels)
                loss, logits = outputs[:2]

                # 3. 计算损失函数
                if multi_gpu:
                    loss = loss.mean()
                if gradient_accumulation > 1:
                    loss = loss / gradient_accumulation

                # 4. 损失函数反向传播
                if fp16:
                    with amp.scale_loss(loss, optimizer) as scaled_loss:
                        scaled_loss.backward()
                        torch.nn.utils.clip_grad_norm_(amp.master_params(optimizer), max_grad_norm)
                else:
                    loss.backward()
                    torch.nn.utils.clip_grad_norm_(model.parameters(), max_grad_norm)

                # 5. 更新参数 optimizer step
                if (step + 1) % gradient_accumulation == 0:
                    running_loss += loss.item()
                    optimizer.step()
                    optimizer.zero_grad()
                    scheduler.step()
                if (step + 1) % log_step == 0:
                    steps_Count += 1
                    print('now time: {}:{}. Step {} / {} of piece {} of epoch {}, loss {}'.format(
                        datetime.datetime.now().hour,
                        datetime.datetime.now().minute,
                        steps_Count,
                        total_steps,
                        len(samples) // batch_size,
                        epoch + 1,
                        running_loss / log_step))
                    running_loss = 0

                if run_pice % 1000 == 0 and run_pice > 999:
                    model_to_save = model.module if hasattr(model, 'module') else model
                    print('保存模型中...')
                    model_to_save.save_pretrained(output_dir)
                run_pice += 1
            piece_num += 1

    print('saving model for epoch {}'.format(epoch + 1))
    if not os.path.exists(output_dir):
        os.mkdir(output_dir)
    model_to_save = model.module if hasattr(model, 'module') else model
    model_to_save.save_pretrained(output_dir)
    print('epoch {} finished'.format(epoch + 1))

    then = datetime.datetime.now()
    print('time: {}'.format(then))
    print('time for one epoch: {}'.format(then - now))

    print('training finished')

    if not os.path.exists(output_dir):
        os.mkdir(output_dir)
    model_to_save = model.module if hasattr(model, 'module') else model
    model_to_save.save_pretrained(output_dir)

if __name__ == '__main__':
    torch.cuda.init()
    main()

6.生成脚本 generate.py

import torch
from transformers import GPT2LMHeadModel
from tokenizations import tokenization_bert

def top_k_top_p_filtering(logits, top_k=0, top_p=0.0, filter_value=-float('Inf')):
    if top_k > 0:
        top_k_values, top_k_indices = torch.topk(logits, top_k, dim=-1)
        logits = logits.masked_fill(logits < torch.max(top_k_values, dim=-1, keepdim=True).values, filter_value)

    if top_p > 0.0:
        sorted_logits, sorted_indices = torch.sort(logits, descending=True)
        cumulative_probs = torch.cumsum(torch.softmax(sorted_logits, dim=-1), dim=-1)
        sorted_indices_to_remove = cumulative_probs > top_p

    if top_k > 0:
        sorted_indices_to_remove[..., :top_k] = 0
        indices_to_remove = sorted_indices[sorted_indices_to_remove]
        mask = torch.zeros_like(logits, dtype=torch.bool).to(device)
        for idx in indices_to_remove:
            mask = torch.logical_or(mask, torch.eq(logits, idx))
        logits = logits.masked_fill(mask, filter_value)

    return logits


def is_word(word):
    for item in list(word):
        if item not in 'qwertyuiopasdfghjklzxcvbnm':
            return False
    return True

def _is_chinese_char(char):
    """Checks whether CP is the codepoint of a CJK character."""
    # This defines a "chinese character" as anything in the CJK Unicode block:
    #   https://en.wikipedia.org/wiki/CJK_Unified_Ideographs_(Unicode_block)
    #
    # Note that the CJK Unicode block is NOT all Japanese and Korean characters,
    # despite its name. The modern Korean Hangul alphabet is a different block,
    # as is Japanese Hiragana and Katakana. Those alphabets are used to write
    # space-separated words, so they are not treated specially and handled
    # like the all of the other languages.
    cp = ord(char)
    if ((cp >= 0x4E00 and cp <= 0x9FFF) or  #
            (cp >= 0x3400 and cp <= 0x4DBF) or  #
            (cp >= 0x20000 and cp <= 0x2A6DF) or  #
            (cp >= 0x2A700 and cp <= 0x2B73F) or  #
            (cp >= 0x2B740 and cp <= 0x2B81F) or  #
            (cp >= 0x2B820 and cp <= 0x2CEAF) or
            (cp >= 0xF900 and cp <= 0xFAFF) or  #
            (cp >= 0x2F800 and cp <= 0x2FA1F)):  #
        return True
    return False

def tokenizer_decode(tokenizer,out_text):
    text = tokenizer.convert_ids_to_tokens(out_text)

    for i, item in enumerate(text[:-1]):  # 确保英文前后有空格
        if is_word(item) and is_word(text[i + 1]):
            text[i] = item + ' '
    for i, item in enumerate(text):
        if '[UNK]' ==item:
            text[i] = ''
        if item == '[CLS]' or item == '[SEP]':
            text[i] = '\n'
        if item == '[PAD]' or '[MASK]' == item:
            text[i] = ' '

    text = ''.join(text)
    return text



def generate_novel(prompt, temperature=0.7, top_k=0, top_p=0.9, length=2000, repetition_penalty=1.0):
    print(prompt, end="")
    # 将输入的 prompt 转化为 token id
    input_ids = tokenizer.encode(prompt, return_tensors='pt').to(device)
    # 生成一个和 input_ids 相同形状的 tensor,全部为 1
    input_mask = torch.ones(input_ids.shape, dtype=torch.long).to(device)

    # 生成的文本初始化为 prompt
    generated_text = tokenizer.decode(input_ids[0], skip_special_tokens=True)
    # 禁用梯度计算
    with torch.no_grad():
        # 控制生成文本长度小于 length
        while len(generated_text) < length:
            # 对 input_ids 进行前向传播,获取输出 logits
            outputs = model(input_ids=input_ids, attention_mask=input_mask)
            logits = outputs.logits[:, -1, :] / temperature
            # 对 logits 进行 top-k 和 top-p 过滤
            filtered_logits = top_k_top_p_filtering(logits, top_k=top_k, top_p=top_p)
            
            # 对已经生成的 token 进行重复惩罚
            for i in range(len(input_ids[0])):
                if input_ids[0][i] == filtered_logits[0].argmax().item():
                    filtered_logits[0][i] /= repetition_penalty
            
            # 计算下一个 token 的概率分布,并采样出下一个 token
            probabilities = torch.softmax(filtered_logits, dim=-1)
            next_token = torch.multinomial(probabilities, num_samples=1)
            # 将生成的 token 拼接到 input_ids 中
            input_ids = torch.cat((input_ids, next_token), dim=1)
            # 重新生成一个和 input_ids 相同形状的 tensor,全部为 1
            input_mask = torch.ones(input_ids.shape, dtype=torch.long).to(device)
            # 将生成的 token 转化为文本,拼接到 generated_text 中
            new_text = tokenizer_decode(tokenizer,next_token[0])
            print(new_text, end="")
            generated_text +=new_text
            # 如果生成的文本长度已经超过 length,结束生成过程
            if len(generated_text) >= length:
                break
    return generated_text


tokenizer = tokenization_bert.BertTokenizer('./vocab.txt')
model = GPT2LMHeadModel.from_pretrained( "./model/")
device = "cuda" if torch.cuda.is_available() else "cpu"
model.to(device)
model.eval()
prompt =  "孙悟空吃完仙桃,"

generate_novel(prompt)

 文本生成效果

第三回情友。却说那沙僧急急抬头观看, 第二指腰尸往里观看,闯入斗柄贺喜环现出鲜红之下,看见八戒者即着脚手往里观看,看见, 着实个活捉了钢刀,半雾,把个灯笼。行者道:“老施主,上禅。那长老看何地方,只见海边此必是救出师父,泼猢狲打破唐僧,拿住得受用枪!” 慌得就问老大慌了手脚,把钉钯轮着诀,对对唐僧,就问曰:“若不是甚么披挂来也!开门,又摇身抵语,有莫打破人头打破了。” 旁有张睁睛看处,钉钯筑了,把个大睁睛看处,原来那怪见有八万四千钢头钻将出来厉声高叫道:“泼猢狲!你从成精之对你这泼物,长的根,却不认得尊神饶命!你不知是个器只叫你,我也?”八戒道:“你,把门的?”八戒道:“你不知,断乎是我们斗瓦喷,把他就跳下何处睡看我,我们且是个假的。” 八戒道:“不要怕,你转钯,皱头绑得甚,把个干净,却将起来,八戒道:“拿得我等我?” 八戒道:“我还未哭得象盘跌了,却就顾得脱了八戒道:“师父不济!我们几口,等不知,就答应。”八戒道:“呆子牵,乃是个假八戒道:“看棍!” 八戒道:“我再不敢看。你使兵,使一条枪枪就去救师,八戒依言,只情打了,八戒道:“正是!正是!” 那长老欢欢喜喜。八戒道:“且顾得脱手。你不知,却又吩咐,等候他绳来!”须臾跪倒,尽睡去寻看去,八戒对八戒道:“亏他绑在那里去了。”好行者道:“正是,只说:“都到此尽皆是假人头下海。但只说开了!我们走过法儿,再不敢归寝,断然倾势,却又从涧枯眼就把他个却又从木儿,把势尽皆看处,却又使尽尽尽尽钯铁棒把势尽尽拔下起,又不见了一下,就变做个一股之内却又只见了:“小的们!果然是甚的们!” 三藏认得他?行者道:“他!” 行者道:“也不怕,看得明白,见驾祥云,到后门边,见了,就赶到山门前枕了手,径至山门,见了一把摸观看。三藏忽抬头看时,慌得只见那僧官叫声“仙童,你下马来至林中,慌得孙大圣开上来接起了,右手泪落的笑道:“拿住了。你怎么就低头看时,那里认得?” 忙忙答礼道:“我不是甚么?” 八戒道:“师父请你从何来?”八戒道:“你从何来?”八戒道:“你多目魔何在?” 八戒道:“你之命,八戒道:“我把你受用!你把我们定,把行李埋,就低头而来。八戒道:“我有一桩这个猴子!不打紧,怎么今日却要回,你!你认他多破了我使尸绑了我们救了,把你将下去,八戒笑道:“你!那呆子不去了,却怎么转要法,却怎么不认得谁?” 八戒道:“我想?你受了!你要蒸死了!你得翻倒一钯逼,却怎么去,放声大哭。” 八戒道:“我。你了,把势!令牌俱念了一下,莫误了,使钯钻入里面走时,又是开之筑倒在空中干鼓撒了!” 八戒道:“八戒道:“兄弟们起个人言,咬着牙,那木叉勒掯兵尽棍好取笑。!打,却将下去戏他赌物景象!”那推云先锋道:“你便就弄本事,呆子!你听我内中树林皎,上前来赶我绑在空中影,倒飞下来,又依旧返隔架遮拦,直在身上,伏尸,倒丹炉念了。毕竟不知休齁,且驾祥云。你看得温苗。却说无事,功完大觉圣,且听下回分解。休教威风无二推倒凶心,修身檄安营破 第六十回黑河潮攀雨车囊施威性本性尽念无心,夜忘解怀车钻儿,休教神狂。休教凶,炬照气滚了性参差。至今终刚强原檄,文章来源地址https://www.toymoban.com/news/detail-647080.html

到了这里,关于GPT2-Chinese 文本生成,训练AI写小说,AI写小说2的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 开启想象翅膀:轻松实现文本生成模型的创作应用,支持LLaMA、ChatGLM、UDA、GPT2、Seq2Seq、BART、T5、SongNet等模型,开箱即用

    TextGen 实现了多种文本生成模型,包括:LLaMA、ChatGLM、UDA、GPT2、Seq2Seq、BART、T5、SongNet等模型,开箱即用。 [2023/06/15] v1.0.0版本: 新增ChatGLM/LLaMA/Bloom模型的多轮对话微调训练,并发布医疗问诊LoRA模型shibing624/ziya-llama-13b-medical-lora。详见Release-v1.0.0 [2023/06/02] v0.2.7版本: 新增ChatG

    2024年02月13日
    浏览(40)
  • 【预训练语言模型】使用Transformers库进行GPT2预训练

    基于 HuggingFace的Transformer库,在Colab或Kaggle进行预训练。 本教程提供:英文数据集wikitext-2和代码数据集的预训练。 注:可以自行上传数据集进行训练 目的 :跑通自回归语言模型的预训练流程 注意:在Colab上训练时,最好将datasets更新到最新版(再重启kernel),避免版本低报

    2024年03月14日
    浏览(42)
  • GPT2训练自己的对话问答机器人

    这里我搭建了虚拟的3.6环境 基于GPT2的中文闲聊机器人,模型实现基于HuggingFace的transformers ,精读GPT2-Chinese的论文和代码,获益匪浅。 data/train.txt:默认的原始训练集文件,存放闲聊语料;data/train.pkl:对原始训练语料进行tokenize之后的文件,存储一个list对象,list的每条数据表示一个

    2024年02月12日
    浏览(64)
  • Midreal AI 互动小说文本生成工具游戏更新了网页版本,不需要在 Discord 里面使用了

    Midreal AI是一款革命性的AI小说生成工具,它不仅能够生成具有逻辑性和创造力的小说,还具备高度的互动能力。用户在使用过程中可以在关键节点选择剧情走向,甚至还能生成配图,使得整个创作过程更加丰富和个性化。Midreal AI的开发背后是MIT、NYU、剑桥、普林斯顿等顶尖大

    2024年04月16日
    浏览(91)
  • 阿里云AIGC- 使用Megatron-Deepspeed训练GPT-2并生成文本

    本文介绍如何使用GPU云服务器,使用 Megatron-Deepspeed框架 训练GPT-2模型并生成文本。 GPT-2模型是OpenAI于 2018年在GPT模型 的基础上发布的新的 无监督NLP模型 ,当时被称为“史上最强通用NLP模型”。该模型可以生成 连贯的文本段落 ,并且能在 未经预训练 的情况下,完成阅读理解

    2024年02月09日
    浏览(50)
  • 大语言模型的预训练[2]:GPT、GPT2、GPT3、GPT3.5、GPT4相关理论知识和模型实现、模型应用以及各个版本之间的区别详解

    在自然语言处理问题中,可从互联网上下载大量无标注数据,而针对具体问题的有标注数据却非常少,GPT 是一种半监督学习方法,它致力于用大量无标注数据让模型学习 “常识”,以缓解标注信息不足的问题。其具体方法是在针对有标签数据训练 Fine-tune 之前,用无标签数据

    2024年02月16日
    浏览(55)
  • 检测文本是否由AI生成,GPT、文心一言等均能被检测

    目前很多机构推出了ChatGPT等AI文本检测工具,但是准确率主打一个模棱两可,基本和抛硬币没啥区别。 先说结论,我们对比了常见的几款AI检测工具,copyleaks检测相比较而言最准确。 来源:GPT3.5 提问词:Redis有什么作用? Redis是一种开源的内存数据库,它具有多种作用和用途

    2024年02月14日
    浏览(69)
  • 手写GPT实现小说生成(一)

    本文开始从零实现GPT1做一个小说续写器,即只需要给出一些文本,让模型帮你续写,主要内容包含: 模型编写 训练适配小说的中文分词器 将小说按固定大小拆分生成数据集 拆分训练/测试集 训练 体验小说续写效果 同时结合HuggingFace的 transformers ,可以将处理好的数据集、训

    2024年01月20日
    浏览(39)
  • 文本生成高精准3D模型,北京智源AI研究院等出品—3D-GPT

    北京智源AI研究院、牛津大学、澳大利亚国立大学联合发布了一项研究—3D-GPT,通过文本问答方式就能创建高精准3D模型。 据悉,3D-GPT使用了大语言模型的多任务推理能力,通过任务调度代理、概念化代理和建模代理三大模块,简化了3D建模的开发流程实现技术民主化。 但3D-

    2024年02月03日
    浏览(45)
  • AIGC:利用多个AI技术前沿模型(GPT-3.5/GPT-4/Claude/ForefrontChat/HuggingChat)实现文本理解、生成文本类/图片类的结果对比并分析性能案例集合

    AIGC:利用多个AI技术前沿模型(GPT-3.5/GPT-4/Claude/ForefrontChat/HuggingChat)实现文本理解、生成文本类/图片类的结果对比并分析性能案例集合 目录 文本理解 1、理解语境中的术语含义 GPT-4的回答 GPT-3.5的回答 Forefront Chat(GPT-3.5)的回答 Claude+的回答 HuggingChat的回答 2、请用一句话总结贝

    2024年02月09日
    浏览(42)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包