CN111858931B - A text generation method based on deep learning - Google Patents

Abstract

The invention discloses a text generation method based on deep learning. The method includes training and testing, wherein the training includes the steps of: constructing a training set, the training set including a plurality of sample pairs composed of preprocessed topics and corresponding texts; pre-defining a generator, the generating The generator is used to generate text according to the input topic, use the training set to pre-train the generator, and add an attention mechanism and a new historical memory information module to the encoding and decoding of the generator; The text output by the generator and the text in the training set are input to the classifier for adversarial training; and the generator is subjected to reinforcement learning training according to the pre-trained generator and the loss function defined by the classifier. The present invention has better text generation effect.

Description

A text generation method based on deep learning

technical field

The invention belongs to the technical field of natural language processing, and more particularly, relates to a text generation method based on deep learning.

Background technique

The emergence of deep learning has brought the development of artificial intelligence to a new level, and has quickly had a profound impact in academia and industry. The method based on deep learning has become a mainstream method in the fields of computer vision and natural language processing. In the field of natural processing, deep learning-based methods have also made great progress. For example, in the fields of machine translation, human-machine dialogue, and ancient poetry generation, deep learning-based methods have completely surpassed or even replaced traditional machine learning methods.

Automatic writing is an important artificial intelligence technology. The use of artificial intelligence to write or assist in creation provides new creative methods and approaches for human beings. Automatic writing has greatly improved the convenience and speed of writing, and has greatly changed the the way people write on a daily basis. However, the previous automatic writing is all template-based automatic writing. Although it can quickly perform automatic writing, it has great defects in novelty and variety, and it is difficult to meet people's requirements for innovation.

The classic deep learning-based text generation methods are all artificial neural network models based on recurrent neural networks (RNNs). The input information is compressed into a fixed-length vector, and then a linear or nonlinear transformation is used to generate text sentence by sentence through a neural network. This type of method has an obvious disadvantage. The model compresses the historical memory information into a state vector of the same length, and each word only considers the historical information transmitted by the previous word, which leads to a serious problem of loss of historical information, so The quality of the text generated later will get worse and worse.

SUMMARY OF THE INVENTION

In view of at least one defect or improvement requirement of the prior art, the present invention provides a text generation method based on deep learning, which has better text generation effect.

In order to achieve the above object, the present invention provides a text generation method based on deep learning, including training and testing, and the training includes steps:

constructing a training set, which includes a plurality of sample pairs composed of preprocessed topics and corresponding texts;

A generator is pre-defined, the generator is used to generate text according to the input topic, the generator is pre-trained by using the training set, the generator includes an encoder and a decoder, and the encoder is used to convert the input The topic is encoded as a word vector, the decoder is a long-short-term memory network using a recurrent neural network, the initial state vector of the long-short-term memory network uses a randomly initialized vector, and the input of the long-short-term memory network includes the previous time step The real output of , the topic vector and the global historical memory vector obtained by the attention mechanism;

Define a classifier in advance, and input the text output by the generator and the text in the training set into the classifier for adversarial training;

Reinforcement learning training is performed on the generator according to the pre-trained generator and the classifier definition loss function.

Preferably, the preprocessing includes: performing keyword segmentation on the text in the sample set, calculating the tf-idf scores of all keywords by using the tf-idf algorithm, and selecting multiple keywords with the highest scores as the topic of each text.

Preferably, the global history memory vector is obtained according to a history memory matrix, the history memory matrix is composed of a vector with a length of L, the history memory matrix is all initialized to 0 at first, and is dynamically stored in the training process before it is generated. In the process of training the generator, the historical memory matrix is not updated with parameters.

Preferably, a gating network is used to obtain the currently required global historical memory vector.

Preferably, the classifier includes a convolutional layer, a pooling layer and a Highway network connected in sequence, and the objective function of the classifier uses a cross-entropy loss function.

Preferably, defining the loss function according to the pre-trained generator and the classifier is specifically: using a penalty-based expectation as an objective function of reinforcement learning training, and the penalty function is based on the classifier and the generator jointly Calculated.

Preferably, the decoder's hidden state vector s _t = LSTM(s _t-1 , [e(y _t-1 ); h _t-1 ; c _t ]), where is the decoder t-1 time steps The hidden state vector of , h _t-1 represents the vector of memory information of t-1 time steps, c _t is the context vector of the topic, c _t is obtained according to the multiplication attention mechanism, and is obtained according to the following formula:

g _tj = v _a ^T C _{t-1, j} tanh(W _a s _t-1 +U _a e(τ _j ))

α _tj =softmax(g _tj )

In the above formula, g _tj represents the attention weight of the t-th time step decoder to the j-th topic τ _j , α _tj is the normalized attention weight of g _tj , v _a , W _a and U _a are all The trainable parameters are initialized using a standard normal distribution, C is the topic coverage vector, and the coverage vector of the jth topic at the t-1th time step is denoted by C _t-1 , _j .

In general, compared with the prior art, the present invention has beneficial effects:

(1) In this paper, two attention mechanisms and a new historical memory module are added to the encoder-decoder architecture. One of the attention mechanisms is used to selectively focus on specific input feature vectors, the new historical memory module as an explicit information storage module can learn and represent the global historical information, and the other attention mechanism is used to learn from A global historical information vector is obtained from the global historical information storage module. This global history information combined with the local history information of the long short-term memory network (LSTM) further increases the long-term dependence of the recurrent neural network on language.

(2) In order to further improve the effect, the ideas of reinforcement learning and adversarial neural network are combined to further increase the topic relevance of the text.

(3) In addition, since topic-based text generation belongs to an open text generation task, the present invention adopts a decoding method based on temperature sampling (Sample with Temperature) to increase the diversity of generated texts.

Description of drawings

1 is a schematic flowchart of a deep learning-based text generation method according to an embodiment of the present invention;

2 is a schematic diagram of a generator according to an embodiment of the present invention;

3 is a schematic diagram of a discriminator according to an embodiment of the present invention;

4 is a schematic diagram of reinforcement learning based on policy gradients according to an embodiment of the present invention;

5 is a schematic diagram of an adversarial neural network training according to an embodiment of the present invention;

FIG. 6 is a schematic diagram of an experimental result of a text generation method based on deep learning according to an embodiment of the present invention.

Detailed ways

In order to make the objectives, technical solutions and advantages of the present invention clearer, the present invention will be further described in detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are only used to explain the present invention, but not to limit the present invention. In addition, the technical features involved in the various embodiments of the present invention described below can be combined with each other as long as they do not conflict with each other.

As shown in FIG. 1 , the deep learning-based text generation method according to the embodiment of the present invention includes the following stages.

Phase 1: Data Preparation

In the data preparation stage, the required text data is first obtained from the web crawler, and the special symbols in the data are cleaned to obtain the required training data.

Secondly, the tf-idf algorithm is used to extract keywords, which specifically includes: performing word segmentation on all articles; removing stop words; calculating tf-idf scores according to tf-idf _ij =tf _ij ×idf _i . Among them, tf _ij is used to measure the frequency of the i-th word in the j-th text, and it is calculated according to the following formula:

where idf _i is the reverse text frequency of the ith word, which is calculated as follows:

The calculated tf-idf _ij represents the tf-idf score of the ith word in the jth article. Sort the tf-idf scores of all words in each article in descending order, take the first 5 words as article keywords, take the extracted keywords as the topic of the article, and then count the word frequencies of all topics, from the 5 words in each article Topics with low frequency (frequency less than 100) are removed from the topics.

Randomly divide the data for the article and topic data obtained above, 85% of all data is used as the training set, 5% is used as the validation set, and the remaining 10% is used as the test set;

Select a suitable dictionary size | V |, use the text to build a phrase to the mapping of the word gauge. The specific method is to add 4 markings in turn at the beginning of the word table. For words not in the vocabulary, <GO> represents the start tag of the text, and <END> represents the end tag of the text. For the new vocabulary, the words in the vocabulary are numbered from 0, a mapping from the number to the word is established, and a mapping from the word to the number is established.

In one of the embodiments, the method further includes: selecting an appropriate text length L, and preprocessing all texts using the vocabulary list constructed above. Add the above <GO> tag at the beginning of each text, add the <END> tag at the end of the text whose length is less than L, and use <PAD> for padding until the total length reaches L, and directly intercept the text whose length is greater than L The length of the text is L, and the <END> terminator is added at the end of the text; for serializing all texts using the above word-to-number mapping dictionary, convert all word-divided texts into word list numbering sequences, for training and testing.

Stage 2: Pretraining the generator model

Construction of the pre-training model. The pre-training model specifically includes an encoder and a decoder; the encoder encodes the topic into a word vector of appropriate dimensions, the decoder uses the long and short-term memory network of the recurrent neural network, and the initial state vector of the long and short-term memory network uses Randomly initialized vector, the topic vector of each time step is obtained using the attention mechanism, and the current topic vector represents the topic semantic information contained in the current word. The current input includes the word vector mapped (corresponding to) the word of the ground truth of the previous time step, the topic vector obtained by the attention mechanism, and a new historical memory vector, which is composed of these three vectors. The current input vector and the state of the previous time step are subjected to the nonlinear transformation of the long short-term memory network (LSTM) to obtain an output vector. This output vector undergoes a layer of linear transformation to convert the last dimension into the vocabulary size, and uses the softmax function. Perform normalization to obtain the probability of occurrence of each word in the vocabulary of the current time step, or the probability distribution of the current vocabulary. We calculate the cross-entropy loss function based on this probability distribution and the 0,1 distribution of the training set labels as the final objective function, and then continuously adjust the parameters of the model according to the batch stochastic gradient descent algorithm and an appropriate learning rate until the model converges. The final probability part is used for decoding to get the final predicted word.

The architecture of the pre-training generator model is shown in Figure 2, and the specific input is set as a set of n topics {τ ₁ , τ ₂ , ..., τ _n }, where n is the preset maximum number of input topics. The input topic gets the unique id of each word through dictionary mapping, and then retrieves e(τ _j ) from the word vector matrix to get the word vector of topic τ _j , the hidden state vector of the decoder s _t =LSTM(s _t-1 , [e(y _t-1 ); h _t-1 ; c _t ]), where s _t-1 is the hidden state vector of the decoder for t-1 time steps. h _t-1 represents the vector of memory information for t-1 time steps, c _t is the context vector of the topic, c _t is obtained according to the multiplicative attention mechanism, and is obtained according to the following formula:

g _tj = v _a ^T C _{t-1, j} tanh(W _a s _t-1 +U _a e(τ _j ))

α _tj =softmax(g _tj )

In the above formula, g _tj represents the attention weight of the t-th time step decoder to the j-th topic τ _j , α _tj is the normalized attention weight of g _tj , v _a , W _a and U _a are all Trainable parameters, initialized using the standard normal distribution.

At the same time, in order to avoid over-repeating some topics and ignoring other topics during generation, we also use a topic coverage vector C. C is initialized with [0, 0, 0, 0, 0], indicating that no topic is expressed at the beginning. At the same time, C is also dynamically updated. For topics that have been expressed before, we reduce the attention weight of these topics, so that the opportunities for these topics to be expressed next are reduced; and for topics that have not been expressed, we increase these topics by increasing The attention weight of , increases the chance of these topics being expressed next. The coverage vector of the jth topic of C at the tth time step is denoted by C _t,j , and it is updated according to the following formula:

where _φj is obtained according to the following formula:

φ _j =N·σ(U _f [e(τ ₁ ), e(τ ₂ ), . . . , e(τ _k )])

In the above formula, N is the number of input topics, U _f is a trainable parameter, and σ is the sigmoid activation function.

Among them, h _t is obtained from a historical memory module, which mainly includes a historical memory matrix HM ^{T ×E} , where T represents the maximum length of the article, and E represents the dimension of the word vector. This historical memory matrix starts with an all-zero matrix for initialization, The representative does not store any memory information at the beginning, and dynamically stores the word vectors generated at each time step before the decoder during the training process, and fills these word vectors into the historical memory matrix. During the training process, the historical memory matrix and No parameter updates, just as a container for storing word vectors.

Since the long-short-term memory network encodes the historical information into two vectors, it causes a certain loss. This historical memory matrix is equivalent to a historical information enhancement module, which is used to make up for the loss of historical information.

As new words are generated, the historical memory matrix is calculated as follows:

HM ^T×E (t)=e(y _t-1 )

To pick on the historical information, we use a gating network that uses the decoder's hidden state vector s _t and two trainable parameters W _h and b _h as input, processed using the tanh activation function, computing as follows:

v _t =tanh(W _h s _t +b _h )HM[t,;]

Perform softmax normalization on the vector v _t obtained by the above gated network as the weight of each word in the historical memory module. According to this weight and the historical memory module, the required historical information vector h _t is selected. The specific calculation is obtained according to the following formula:

h _t =softmax(v _t )HM ^T×E

The final distribution of the model at the t-th time step is obtained according to the following formula:

p(y _t |y _{1 : t-1} , τ _{1 : k} )=softmaqx(W _o s _t )

where W _o is a learnable parameter, initialized using a standard normal distribution.

In the training phase, the model uses the cross-entropy loss function as the objective function to train the model, the formula is as follows:

where q(t) is the distribution of the real output, using one hot encoding, and p(t) is the distribution predicted by the model.

In the prediction phase, the model predicts that the word y _t at time t is sampled based on the following distribution:

y _t ~p(y _t |y _{1: t-1} , τ _{1: k} )

Stage 3: Train a multi-topic classifier

Build a multi-class discriminator. As shown in Figure 2, this multi-classifier specifically includes a convolutional layer, followed by a maximum pooling layer, and a high-speed network (Highway Network), and the objective function uses the cross-entropy loss function. The data of the multi-classifier comes from the training set and the data generated by the previous pre-training generator. The label dimension is T+1, T represents the number of labels contained in the data set, and another label indicates that the current text is the data of the training set Also the generated data for the pretrained generator.

代表向量的拼接，文本特征序列向量π_1：T∈R^T×E，ω∈R^l×E，卷积核的长度为E和词向量的维度一致,卷积核的宽度为l，词语卷积和激活函数映射得到特征向量

再使用最大池化和一个Highway网络得到最终的输出类别分布D_φ(x_j|y_1：T）。目标是交叉熵损失函数，公式如下：The architecture of the discriminator is shown in Figure 3. The discriminator is a text multi-classifier with n+1 targets, of which n targets are the n topics to which the text belongs, and the other is used to determine whether the text is generated by the model or not. actual training samples. The input of the classifier consists of two parts, the real training data and the data generated by the pre-training generator. The input text sequence y ₁ , y ₂ , ..., y _T is a feature vector obtained by a two-dimensional convolution

Represents the concatenation of vectors, the text feature sequence vector π _{1: T} ∈ R ^T×E , ω∈R ^l×E , the length of the convolution kernel is E and the dimension of the word vector is the same, the width of the convolution kernel is l, the word volume Product and activation function mapping to get feature vector

Then use max pooling and a Highway network to get the final output class distribution D _φ (x _j |y _1:T ). The target is the cross-entropy loss function with the following formula:

Among them, x _j is a topic label of the input text sequence y _1:T , using one hot encoding, there are n+1 in total, the last label indicates whether the text is real data, the model uses Adam gradient descent algorithm Update parameters.

The generator and multi-classifier are initialized, and word vectors are randomly initialized using a standard normal distribution. The other weights are initialized using normal with mean 0 and variance 0.01. Initialize a suitable batch size batch_size, which is the number of pieces of data fed to the model at one time, and initialize the learning rate to 0.01;

Pre-train the generator and the multi-segmenter, and randomly scramble the training data in each round. First, the generator is pre-trained, and then the pre-training generator is used to generate the same amount of data as the training set. The multi-classified data set is scrambled; secondly, the multi-classifier is pre-trained, and the stochastic gradient descent algorithm is used to update the weights of each layer of the network until the network converges.

Stage 4: Building the Reinforcement Learning Generator

Build the reinforcement learning module, which consists of a new generator and the above multi-classifier. The new generator modifies the loss function on the basis of the pre-trained generator, and uses the penalty-based expectation as the objective function of the reinforcement learning model. The penalty function is jointly calculated according to the multi-topic classifier and the new generator.

Since the goal of training with maximum likelihood estimation (MLE) is to seek the solution with the highest probability at each step, but in fact words with low probability in the text will also appear, which will lead to the inconsistency between the model and the actual generation intention. Reinforcement learning does not require each step to be an optimal solution, but seeks the solution with the largest cumulative report. Words with low probability are allowed to appear in the middle. The maximum likelihood pursues the local optimal solution, and reinforcement learning pursues the global optimal solution, so Reinforcement learning is more likely to find such grammar generation rules that conform to human language cognition. As shown in Figure 4, in the text generation, the reinforcement learning agent (agent) can be regarded as a generator, the figure is represented by G, the reinforcement learning environment is represented by a multi-classifier D, the state of the agent (state ) is the set of previously generated words (tokens), which are represented by solid black dots in the figure. The action of reinforcement learning is the word (token) that the agent can choose in the next step. We introduce the method of policy gradient, at _t represents the token predicted by the model at the t-th time step, and the policy π represents how we use All tokens for which the strategy generates text. Then reinforcement learning is to determine this policy π. Then we parameterize the policy π, P _θ (a|s) under the condition of s = {a ₁ , a ₂ , ..., a _n }, the probability that the next token selected by the model agent is a. Here our strategy is G _θ (y _t+1 |y _{1: t} ), and the loss function of deep reinforcement learning is as follows:

The penalty factor Penalty is calculated according to whether the current sequence has generated the last word in the following two cases:

As shown in Figure 4, the reward of the discriminator is not directly used as the feedback of reinforcement learning, but the punishment is used as the feedback of the environment to the agent, so our strategy should minimize the cumulative penalty. Since we need to obtain the current cumulative expectation penalty for each action, when we generate the t-th word, we need to use Monte Carlo (MenteCarlo) sampling to obtain the remaining T-t tokens, and use the discriminator to calculate the current Instantaneous cumulative penalty (Penalty). The addition of reinforcement learning can make our generated text more topic-relevant.

Stage 5: Training with Adversarial Neural Networks

As shown in Figure 5, the adversarial neural network consists of a generator and a discriminator. The reinforcement learning generator described in the generator experiment phase 5, in the process of adversarial learning, on the one hand, the generator generates texts that are more like training data and topic-related through learning evolution, and on the other hand, the discriminator recognizes the generated text through learning evolution. The text generated by the generator and guide the evolution of the generator.

Adversarial learning is added because when the previous reinforcement learning makes the generator stronger, the discriminator's ability will be weakened. Once the discriminator's discrimination ability is weakened, the reward calculation of reinforcement learning will be biased. The existence of sampling variance will make the reinforcement learning training unstable, so after the parameter update of reinforcement learning, the log-likelihood (MLE) objective function is also added to correct the reinforcement learning generator and slow down the fluctuations in the training process.

Due to the need to train the discriminator and the generator at the same time in the training process of the adversarial neural network, the training speed of the anti-neural network is relatively slow and it is difficult to converge. In order to solve these problems, on the one hand, the multi-topic classifier and the pre-training generator need to be fully pre-trained before the training of the adversarial neural network, which also helps the convergence of the model. On the other hand, when adversarial learning training, choose a smaller training period (1 to 3), an excessively large training period not only wastes computing resources, but may also overfit.

Stage 6: Model Selection and Testing

Since the task itself belongs to open text generation, using greedy decoding or beam search decoding will make the generated text too single, and the repetition phenomenon is serious. Therefore, in the embodiment of the present invention, the decoding method of sampling is used to increase the diversity of the generated text. Through sample-based decoding, the embodiments of the present invention can generate more diverse texts. And the sampling method can effectively avoid word repetition phenomenon. In addition, the embodiments of the present invention use sampling-based decoding during training and testing, which alleviates the problem of exposing bias caused by inconsistent training and testing decoding methods to a certain extent.

Several models are compared on the public data set, and experiments prove that the text generation method of the embodiment of the present invention can generate more topic-related text, and is more fluent and fluent. In the decoding process, we use distributed sampling-based decoding to increase the diversity of generated text and reduce the occurrence of repetitive text generation.

In order to verify the effectiveness of the embodiments of the present invention, experimental verification is carried out on the public data set:

The experiment uses the zhihu data set published by Harbin Institute of Technology in 2018. In terms of the BLEU score of the text automatic evaluation index, the model of the embodiment of the present invention is improved by 37% compared with the baseline model, and improved by 6% compared with the current best model. In terms of manual evaluation, the short text score generated by the model of the embodiment of the present invention also achieves the best results. The text generated by the method of the embodiment of the present invention is shown in FIG. 6 .

It must be noted that, in any of the above embodiments, the methods are not necessarily executed in sequence, and as long as it cannot be inferred from the execution logic that the methods must be executed in a certain sequence, it means that the methods can be executed in any other possible sequence.

Those skilled in the art can easily understand that the above are only preferred embodiments of the present invention, and are not intended to limit the present invention. Any modifications, equivalent replacements and improvements made within the spirit and principles of the present invention, etc., All should be included within the protection scope of the present invention.

Claims (7)

1. a text generation method based on deep learning, comprising training and testing, is characterized in that, comprises: Stage 1: Data preparation, the data preparation stage first obtains the required text data from the web crawler, cleans the special symbols in the data, and obtains the required training data; Stage 2: Construction of the pre-training model. The pre-training model specifically includes an encoder and a decoder; the encoder encodes the topic into word vectors of appropriate dimensions, and the decoder uses a long-short-term memory network of recurrent neural networks. The state vector uses a randomly initialized vector, the topic vector of each time step is obtained using the attention mechanism, and the current topic vector represents the topic semantic information contained in the current word; Set the specific input to be a set of n topics {τ ₁ , τ ₂ , ..., τ _n }, where n is the preset maximum number of input topics, and the input topics get the unique id of each word through dictionary mapping , and then retrieved from the word vector matrix to obtain e(τ _j ) as the word vector of topic τ _j , the hidden state vector of the decoder s _t =LSTM(s _t-1 ,[e(y _t-1 );h _{t- 1} ;c _t ]), where s _t-1 is the hidden state vector of the decoder for t-1 time steps, h _t-1 represents the vector of memory information for t-1 time steps, and c _t is the context vector of the topic , c _t is obtained according to the multiplicative attention mechanism, and is obtained according to the following formula: g _tj = v _a ^T C _{t-1, j} tanh(W _a s _t-1 +U _a e(τ _j )) α _tj =softmax(g _tj )

In the above formula, g _tj represents the attention weight of the t-th time step decoder to the j-th topic τ _j , α _tj is the normalized attention weight of g _tj , v _a , W _a and U _a are all Trainable parameters, initialized using a standard normal distribution; The coverage vector of the jth topic of C at the tth time step is denoted by C _t,j , and it is updated according to the following formula:

The coverage vector of the jth topic of C at the t-1th time step is denoted by C _t-1,j , where _φj is obtained according to the following formula: φ _j =N·σ(U _f [e(τ ₁ ), e(τ ₂ ), . . . , e(τ _k )]) In the above formula, N is the number of input topics, U _f is a trainable parameter, and σ is the sigmoid activation function; Among them, h _t is obtained from a historical memory module. The historical memory module mainly includes a historical memory matrix HM ^T×E , where T represents the maximum length of the article, and E represents the dimension of the word vector. This historical memory matrix begins to use an all-zero matrix for initialization, The representative does not store any memory information at the beginning, and dynamically stores the word vectors generated at each time step before the decoder during the training process, and fills these word vectors into the historical memory matrix. During the training process, the historical memory matrix and No parameter update, just as a container for storing word vectors, As new words are generated, the historical memory matrix is calculated as follows: HM ^T×E (t)=e(y _t-1 ) For the selection of historical information, a gating network is used, which uses the decoder's hidden state vector s _t and two trainable parameters W _h and b _h as input, processed using the tanh activation function, calculated as follows : υ _t =tanh(W _h s _t +b _h )HM[t,;] Perform soft max normalization on the vector υ _t obtained by the above gated network as the weight of each word in the historical memory module. According to this weight and the historical memory module, the required historical information vector h _t is selected. The specific calculation is obtained according to the following formula : h _t =softmax(v _t )HM ^T×E The final distribution p(y _t |y _{1 : t-1} , τ _{1 : k} ) at the t-th time step of the model is obtained according to the following formula: p(y _t |y _{1 : h-1} , τ _{1 : k} )=softmax(W _o s _t ) where W _o is a learnable parameter, initialized using a standard normal distribution, In the training phase, the model uses the cross-entropy loss function as the objective function to train the model, the formula is as follows:

where q(t) is the distribution of the real output, using one-hot encoding, and p(t) is the distribution predicted by the model; In the prediction phase, the model predicts that the word y _t at time t is sampled based on the following distribution: y _t ~p(y _t |y _{1: t-1} , τ _{1: k} ) Stage 3: Train a multi-topic classifier and build a multi-class discriminator. The discriminator is a text multi-classifier with n+1 targets, of which n targets are the n topics to which the text belongs, and the other is used for To judge whether the text is generated by the model or the actual training sample, the input of the classifier consists of two parts, the real training data and the data generated by the pre-training generator. The input text sequence y ₁ , y ₂ , ..., y _T , The feature vector obtained by a two-dimensional convolution

Represents the concatenation of vectors, the text feature sequence vector π _{1: T} ∈ R ^T×E , ω∈R ^l×E , the length of the convolution kernel is E and the dimension of the word vector is the same, the width of the convolution kernel is l, the word volume Product and activation function mapping to get feature vector

Then use max pooling and a Highway network to get the final output category distribution D _φ (x _j |y _1:T ); Stage 4: Build a reinforcement learning generator. In text generation, the reinforcement learning agent can be regarded as a generator, which is represented by G, and the reinforcement learning environment is represented by a multi-classifier D. The state of the agent is the previous generation. The set of words, the words that can be selected by the agent in the next step of the reinforcement learning action, and the method of introducing the policy gradient, a _t represents the words predicted by the model at the t-th time step, and the strategy π represents the strategy by which all tokens of the text are generated, then Reinforcement learning is to determine the strategy π, and then parameterize the strategy π, P _θ (a|s) indicates that under the condition of s={a ₁ , a ₂ ,..., a _n }, the next selected by the model The probability that the word is a, the strategy is G _θ (y _t+1 |y _1:t ), and the loss function J _G of deep reinforcement learning is as follows:

The penalty factor Penalty is calculated according to whether the current sequence has generated the last word in the following two cases:

Stage 5: Using adversarial neural network training, the adversarial neural network consists of a generator and a discriminator. In the process of adversarial learning, on the one hand, the generator generates texts that are more like training data and topic-related through learning evolution, and the other The aspect discriminator recognizes the text generated by the generator through learning evolution and guides the evolution of the generator; Stage 6: Model selection and testing; The training includes the steps: constructing a training set, which includes a plurality of sample pairs composed of preprocessed topics and corresponding texts; A generator is pre-defined, the generator is used to generate text according to the input topic, the generator is pre-trained by using the training set, the generator includes an encoder and a decoder, and the encoder is used to convert the input The topic is encoded as a word vector, the decoder is a long-short-term memory network using a recurrent neural network, the initial state vector of the long-short-term memory network uses a randomly initialized vector, and the input of the long-short-term memory network includes the previous time step The real output of , the topic vector and the global historical memory vector obtained by the attention mechanism; Define a classifier in advance, and input the text output by the generator and the text in the training set into the classifier for adversarial training; Reinforcement learning training is performed on the generator according to the pre-trained generator and the classifier definition loss function. 2. A kind of text generation method based on deep learning as claimed in claim 1 is characterized in that, described preprocessing comprises: carry out keyword word segmentation to the text in the sample set, use tf-idf algorithm to calculate tf of all keywords -idf score, select multiple keywords with the highest scores as the topic of each text. 3. a kind of text generation method based on deep learning as claimed in claim 1 is characterized in that, described global historical memory vector is obtained according to historical memory matrix, described historical memory matrix is formed by the vector of length L, described The history memory matrix is initially initialized to 0, and the previously generated word vectors are dynamically stored during the training process. During the training process of the generator, the history memory matrix is not updated with parameters. 4. A deep learning-based text generation method according to claim 3, wherein a gating network is used to obtain the currently required global historical memory vector. 5. A deep learning-based text generation method according to claim 1, wherein the classifier comprises a convolutional layer, a pooling layer and a Highway network connected in sequence, and the objective function of the classifier uses Cross-entropy loss function. 6. The method for generating text based on deep learning according to claim 1, wherein the defining a loss function according to the pre-trained generator and the classifier is specifically: using a penalty-based expectation as The objective function of reinforcement learning training, and the penalty function is jointly calculated according to the classifier and the generator. 7. a kind of text generation method based on deep learning as claimed in claim 1 is characterized in that, The decoder's hidden state vector s _t = LSTM(s _t-1 , [e(y _t-1 ); h _t-1 ; c _t ]), where is the hidden state of the decoder t-1 time steps vector, h _t-1 represents the vector of memory information of _t -1 time steps, ct is the context vector of the topic, _ct is obtained according to the multiplicative attention mechanism, and is obtained according to the following formula: g _tj = v _a ^T C _{t-1, j} tanh(W _a s _t-1 +U _a e(τ _j )) α _tj =softmax(g _tj )

In the above formula, g _tj represents the attention weight of the t-th time step decoder to the j-th topic τ _j , α _tj is the normalized attention weight of g _tj , v _a , W _a and U _a are all The trainable parameters are initialized using a standard normal distribution, C is the topic coverage vector, and the coverage vector of the jth topic at the t-1th time step is denoted by C _t-1,j .

Images