数据分析 在Python中实现文本分类(附代码、数据集)

手把手教你在Python中实现文本分类（附代码、数据集）引言文本分类是商业问题中常见的自然语言处理任务，目标是自动将文本文件分到一个或多个已定义好的类别中。文本分类的一些例子如下：分析社交媒体中的大众情感鉴别垃圾邮件和非垃圾邮件自动标注客户问询将新闻文章按主题分类目录本文将详细介绍文本分类问题并用Python实现这个过程：文本分类是有监督学习的一个例子，它使用包含文本文档和标签的数据集来训练一个分类器。端到端的文本分类训练主要由三个部分组成：1.准备数据集：第一步是准备数据集，包括加载数据集和执行基本预处理，然后把数据集分为训练集和验证集。特征工程：第二步是特征工程，将原始数据集被转换为用于训练机器学习模型的平坦特征（flatfeatures），并从现有数据特征创建新的特征。2.模型训练：最后一步是建模，利用标注数据集训练机器学习模型。3.进一步提高分类器性能：本文还将讨论用不同的方法来提高文本分类器的性能。注意：本文不深入讲述NLP任务，如果你想先复习下基础知识，可以通过这篇文章/blog/2017/01/ultimate-guide-to-understand-implement-natural-language-processing-codes-in-python/准备好你的机器先安装基本组件，创建Python的文本分类框架。首先导入所有所需的库。如果你没有安装这些库，可以通过以下官方链接来安装它们。Pandas:/pandas-docs/stable/install.htmlScikit-learn:/stable/install.htmlXGBoost:http://xgboost.readthedocs.io/en/latest/build.htmlTextBlob:http://textblob.readthedocs.io/en/dev/install.htmlKeras:https://keras.io/#installation#导入数据集预处理、特征工程和模型训练所需的库fromsklearnimportmodel_selection,preprocessing,linear_model,naive_bayes,metrics,svmfromsklearn.feature_extraction.textimportTfidfVectorizer,CountVectorizerfromsklearnimportdecomposition,ensembleimportpandas,xgboost,numpy,textblob,stringfromkeras.preprocessingimporttext,sequencefromkerasimportlayers,models,optimizers一、准备数据集在本文中，我使用亚马逊的评论数据集，它可以从这个链接下载：/kunalj101/ad1d9c58d338e20d09ff26bcc06c4235这个数据集包含3.6M的文本评论内容及其标签，我们只使用其中一小部分数据。首先，将下载的数据加载到包含两个列（文本和标签）的pandas的数据结构（dataframe）中。数据集链接：/drive/folders/0Bz8a_Dbh9Qhbfll6bVpmNUtUcFdjYmF2SEpmZUZUcVNiMUw1TWN6RDV3a0JHT3kxLVhVR2M#加载数据集data=open('data/corpus').read()labels,texts=[],[]fori,lineinenumerate(data.split("\n")):content=line.split()labels.append(content[0])texts.append(content[1])#创建一个dataframe，列名为text和labeltrainDF=pandas.DataFrame()trainDF['text']=textstrainDF['label']=labels接下来，我们将数据集分为训练集和验证集，这样我们可以训练和测试分类器。另外，我们将编码我们的目标列，以便它可以在机器学习模型中使用:#将数据集分为训练集和验证集train_x,valid_x,train_y,valid_y=model_selection.train_test_split(trainDF['text'],trainDF['label'])#label编码为目标变量encoder=preprocessing.LabelEncoder()train_y=encoder.fit_transform(train_y)valid_y=encoder.fit_transform(valid_y)二、特征工程接下来是特征工程，在这一步，原始数据将被转换为特征向量，另外也会根据现有的数据创建新的特征。为了从数据集中选出重要的特征，有以下几种方式：计数向量作为特征TF-IDF向量作为特征单个词语级别多个词语级别（N-Gram）词性级别词嵌入作为特征基于文本/NLP的特征主题模型作为特征接下来分别看看它们如何实现：2.1计数向量作为特征计数向量是数据集的矩阵表示，其中每行代表来自语料库的文档，每列表示来自语料库的术语，并且每个单元格表示特定文档中特定术语的频率计数：#创建一个向量计数器对象count_vect=CountVectorizer(analyzer='word',token_pattern=r'\w{1,}')count_vect.fit(trainDF['text'])#使用向量计数器对象转换训练集和验证集xtrain_count=

count_vect.transform(train_x)xvalid_count=

count_vect.transform(valid_x)2.2TF-IDF向量作为特征TF-IDF的分数代表了词语在文档和整个语料库中的相对重要性。TF-IDF分数由两部分组成：第一部分是计算标准的词语频率（TF），第二部分是逆文档频率（IDF）。其中计算语料库中文档总数除以含有该词语的文档数量，然后再取对数就是逆文档频率。TF(t)=（该词语在文档出现的次数）/（文档中词语的总数）IDF(t)=log_e（文档总数/出现该词语的文档总数）TF-IDF向量可以由不同级别的分词产生（单个词语，词性，多个词（n-grams））词语级别TF-IDF：矩阵代表了每个词语在不同文档中的TF-IDF分数。N-gram级别TF-IDF:N-grams是多个词语在一起的组合，这个矩阵代表了N-grams的TF-IDF分数。词性级别TF-IDF：矩阵代表了语料中多个词性的TF-IDF分数。#词语级tf-idftfidf_vect=TfidfVectorizer(analyzer='word',token_pattern=r'\w{1,}',max_features=5000)tfidf_vect.fit(trainDF['text'])xtrain_tfidf=

tfidf_vect.transform(train_x)xvalid_tfidf=

tfidf_vect.transform(valid_x)#ngram级tf-idftfidf_vect_ngram=TfidfVectorizer(analyzer='word',token_pattern=r'\w{1,}',ngram_range=(2,3),max_features=5000)tfidf_vect_ngram.fit(trainDF['text'])xtrain_tfidf_ngram=

tfidf_vect_ngram.transform(train_x)xvalid_tfidf_ngram=

tfidf_vect_ngram.transform(valid_x)#词性级tf-idftfidf_vect_ngram_chars=TfidfVectorizer(analyzer='char',token_pattern=r'\w{1,}',ngram_range=(2,3),max_features=5000)tfidf_vect_ngram_chars.fit(trainDF['text'])xtrain_tfidf_ngram_chars=

tfidf_vect_ngram_chars.transform(train_x)

xvalid_tfidf_ngram_chars=

tfidf_vect_ngram_chars.transform(valid_x)

2.3词嵌入词嵌入是使用稠密向量代表词语和文档的一种形式。向量空间中单词的位置是从该单词在文本中的上下文学习到的，词嵌入可以使用输入语料本身训练，也可以使用预先训练好的词嵌入模型生成，词嵌入模型有：Glove,FastText,Word2Vec。它们都可以下载，并用迁移学习的方式使用。想了解更多的词嵌入资料，可以访问：/blog/2017/06/word-embeddings-count-word2veec/接下来介绍如何在模型中使用预先训练好的词嵌入模型，主要有四步：1.

加载预先训练好的词嵌入模型2.

创建一个分词对象3.

将文本文档转换为分词序列并填充它们4.

创建分词和各自嵌入的映射#加载预先训练好的词嵌入向量embeddings_index={}fori,lineinenumerate(open('data/wiki-news-300d-1M.vec')):values=line.split()embeddings_index[values[0]]=numpy.asarray(values[1:],dtype='float32')#创建一个分词器token=text.Tokenizer()token.fit_on_texts(trainDF['text'])word_index=token.word_index#将文本转换为分词序列，并填充它们保证得到相同长度的向量train_seq_x=sequence.pad_sequences(token.texts_to_sequences(train_x),maxlen=70)valid_seq_x=sequence.pad_sequences(token.texts_to_sequences(valid_x),maxlen=70)#创建分词嵌入映射embedding_matrix=numpy.zeros((len(word_index)+1,300))forword,iinword_index.items():embedding_vector=embeddings_index.get(word)ifembedding_vectorisnotNone:embedding_matrix[i]=embedding_vector2.4基于文本/NLP的特征创建许多额外基于文本的特征有时可以提升模型效果。比如下面的例子：文档的词语计数—文档中词语的总数量文档的词性计数—文档中词性的总数量文档的平均字密度--文件中使用的单词的平均长度完整文章中的标点符号出现次数--文档中标点符号的总数量整篇文章中的大写次数—文档中大写单词的数量完整文章中标题出现的次数—文档中适当的主题（标题）的总数量词性标注的频率分布名词数量动词数量形容词数量副词数量代词数量这些特征有很强的实验性质，应该具体问题具体分析。trainDF['char_count']=trainDF['text'].apply(len)trainDF['word_count']=trainDF['text'].apply(lambdax:len(x.split()))trainDF['word_density']=trainDF['char_count']/(trainDF['word_count']+1)trainDF['punctuation_count']=trainDF['text'].apply(lambdax:len("".join(_for_inxif_instring.punctuation)))

trainDF['title_word_count']=trainDF['text'].apply(lambdax:len([wrdforwrdinx.split()ifwrd.istitle()]))trainDF['upper_case_word_count']=trainDF['text'].apply(lambdax:len([wrdforwrdinx.split()ifwrd.isupper()]))trainDF['char_count']=trainDF['text'].apply(len)trainDF['word_count']=trainDF['text'].apply(lambdax:len(x.split()))trainDF['word_density']=trainDF['char_count']/(trainDF['word_count']+1)trainDF['punctuation_count']=trainDF['text'].apply(lambdax:len("".join(_for_inxif_instring.punctuation)))

trainDF['title_word_count']=trainDF['text'].apply(lambdax:len([wrdforwrdinx.split()ifwrd.istitle()]))trainDF['upper_case_word_count']=trainDF['text'].apply(lambdax:len([wrdforwrdinx.split()ifwrd.isupper()]))pos_family={'noun':['NN','NNS','NNP','NNPS'],'pron':['PRP','PRP$','WP','WP$'],'verb':['VB','VBD','VBG','VBN','VBP','VBZ'],'adj':

['JJ','JJR','JJS'],'adv':['RB','RBR','RBS','WRB']}#检查和获得特定句子中的单词的词性标签数量defcheck_pos_tag(x,flag):cnt=0try:wiki=textblob.TextBlob(x)fortupinwiki.tags:ppo=list(tup)[1]ifppoinpos_family[flag]:cnt+=1except:passreturncnttrainDF['noun_count']=trainDF['text'].apply(lambdax:check_pos_tag(x,'noun'))trainDF['verb_count']=trainDF['text'].apply(lambdax:check_pos_tag(x,'verb'))trainDF['adj_count']=trainDF['text'].apply(lambdax:check_pos_tag(x,'adj'))trainDF['adv_count']=trainDF['text'].apply(lambdax:check_pos_tag(x,'adv'))trainDF['pron_count']=trainDF['text'].apply(lambdax:check_pos_tag(x,'pron'))2.5主题模型作为特征主题模型是从包含重要信息的文档集中识别词组（主题）的技术，我已经使用LDA生成主题模型特征。LDA是一个从固定数量的主题开始的迭代模型，每一个主题代表了词语的分布，每一个文档表示了主题的分布。虽然分词本身没有意义，但是由主题表达出的词语的概率分布可以传达文档思想。如果想了解更多主题模型，请访问：/blog/2016/08/beginners-guide-to-topic-modeling-in-python/我们看看主题模型运行过程：#训练主题模型lda_model=decomposition.LatentDirichletAllocation(n_components=20,learning_method='online',max_iter=20)X_topics=lda_model.fit_transform(xtrain_count)topic_word=lda_ponents_

vocab=count_vect.get_feature_names()#可视化主题模型n_top_words=10topic_summaries=[]fori,topic_distinenumerate(topic_word):topic_words=numpy.array(vocab)[numpy.argsort(topic_dist)][:-(n_top_words+1):-1]topic_summaries.append(''.join(topic_words)三、建模文本分类框架的最后一步是利用之前创建的特征训练一个分类器。关于这个最终的模型，机器学习中有很多模型可供选择。我们将使用下面不同的分类器来做文本分类：朴素贝叶斯分类器线性分类器支持向量机（SVM）BaggingModelsBoostingModels浅层神经网络深层神经网络卷积神经网络（CNN）LSTMGRU双向RNN循环卷积神经网络（RCNN）其它深层神经网络的变种接下来我们详细介绍并使用这些模型。下面的函数是训练模型的通用函数，它的输入是分类器、训练数据的特征向量、训练数据的标签，验证数据的特征向量。我们使用这些输入训练一个模型，并计算准确度。deftrain_model(classifier,feature_vector_train,label,feature_vector_valid,is_neural_net=False):#fitthetrainingdatasetontheclassifierclassifier.fit(feature_vector_train,label)#predictthelabelsonvalidationdatasetpredictions=classifier.predict(feature_vector_valid)ifis_neural_net:predictions=predictions.argmax(axis=-1)returnmetrics.accuracy_score(predictions,valid_y)3.1朴素贝叶斯利用sklearn框架，在不同的特征下实现朴素贝叶斯模型。朴素贝叶斯是一种基于贝叶斯定理的分类技术，并且假设预测变量是独立的。朴素贝叶斯分类器假设一个类别中的特定特征与其它存在的特征没有任何关系。想了解朴素贝叶斯算法细节可点击：ANaiveBayesclassifierassumesthatthepresenceofaparticularfeatureinaclassisunrelatedtothepresenceofanyotherfeature#特征为计数向量的朴素贝叶斯accuracy=train_model(naive_bayes.MultinomialNB(),xtrain_count,train_y,xvalid_count)print"NB,CountVectors:",accuracy#特征为词语级别TF-IDF向量的朴素贝叶斯accuracy=train_model(naive_bayes.MultinomialNB(),xtrain_tfidf,train_y,xvalid_tfidf)print"NB,WordLevelTF-IDF:",accuracy#特征为多个词语级别TF-IDF向量的朴素贝叶斯accuracy=train_model(naive_bayes.MultinomialNB(),xtrain_tfidf_ngram,train_y,xvalid_tfidf_ngram)print"NB,N-GramVectors:",accuracy#特征为词性级别TF-IDF向量的朴素贝叶斯accuracy=train_model(naive_bayes.MultinomialNB(),xtrain_tfidf_ngram_chars,train_y,xvalid_tfidf_ngram_chars)print"NB,CharLevelVectors:",accuracy#输出结果NB,CountVectors:

0.7004NB,WordLevelTF-IDF:

0.7024NB,N-GramVectors:

0.5344NB,CharLevelVectors:

0.68723.2线性分类器实现一个线性分类器（LogisticRegression）：Logistic回归通过使用logistic/sigmoid函数估计概率来度量类别因变量与一个或多个独立变量之间的关系。如果想了解更多关于logistic回归，请访问：/blog/2015/10/basics-logistic-regression/#LinearClassifieronCountVectorsaccuracy=train_model(linear_model.LogisticRegression(),xtrain_count,train_y,xvalid_count)print"LR,CountVectors:",accuracy#特征为词语级别TF-IDF向量的线性分类器accuracy=train_model(linear_model.LogisticRegression(),xtrain_tfidf,train_y,xvalid_tfidf)print"LR,WordLevelTF-IDF:",accuracy#特征为多个词语级别TF-IDF向量的线性分类器accuracy=train_model(linear_model.LogisticRegression(),xtrain_tfidf_ngram,train_y,xvalid_tfidf_ngram)print"LR,N-GramVectors:",accuracy#特征为词性级别TF-IDF向量的线性分类器accuracy=train_model(linear_model.LogisticRegression(),xtrain_tfidf_ngram_chars,train_y,xvalid_tfidf_ngram_chars)print"LR,CharLevelVectors:",accuracy#输出结果LR,CountVectors:

0.7048LR,WordLevelTF-IDF:

0.7056LR,N-GramVectors:

0.4896LR,CharLevelVectors:

0.70123.3实现支持向量机模型支持向量机（SVM）是监督学习算法的一种，它可以用来做分类或回归。该模型提取了分离两个类的最佳超平面或线。如果想了解更多关于SVM，请访问：/blog/2017/09/understaing-support-vector-machine-example-code/#特征为多个词语级别TF-IDF向量的SVMaccuracy=train_model(svm.SVC(),xtrain_tfidf_ngram,train_y,xvalid_tfidf_ngram)print"SVM,N-GramVectors:",accuracy#输出结果SVM,N-GramVectors:

0.52963.4BaggingModel实现一个随机森林模型：随机森林是一种集成模型，更准确地说是Baggingmodel。它是基于树模型家族的一部分。如果想了解更多关于随机森林，请访问：/blog/2014/06/introduction-random-forest-simplified/#特征为计数向量的RFaccuracy=train_model(ensemble.RandomForestClassifier(),xtrain_count,train_y,xvalid_count)print"RF,CountVectors:",accuracy#特征为词语级别TF-IDF向量的RFaccuracy=train_model(ensemble.RandomForestClassifier(),xtrain_tfidf,train_y,xvalid_tfidf)print"RF,WordLevelTF-IDF:",accuracy#输出结果RF,CountVectors:

0.6972RF,WordLevelTF-IDF:

0.69883.5BoostingModel实现一个Xgboost模型：Boostingmodel是另外一种基于树的集成模型。Boosting是一种机器学习集成元算法，主要用于减少模型的偏差，它是一组机器学习算法，可以把弱学习器提升为强学习器。其中弱学习器指的是与真实类别只有轻微相关的分类器（比随机猜测要好一点）。如果想了解更多，请访问：/blog/2016/01/xgboost-algorithm-easy-steps/#特征为计数向量的Xgboostaccuracy=train_model(xgboost.XGBClassifier(),xtrain_count.tocsc(),train_y,xvalid_count.tocsc())print"Xgb,CountVectors:",accuracy#特征为词语级别TF-IDF向量的Xgboostaccuracy=train_model(xgboost.XGBClassifier(),xtrain_tfidf.tocsc(),train_y,xvalid_tfidf.tocsc())print"Xgb,WordLevelTF-IDF:",accuracy#特征为词性级别TF-IDF向量的Xgboostaccuracy=train_model(xgboost.XGBClassifier(),xtrain_tfidf_ngram_chars.tocsc(),train_y,xvalid_tfidf_ngram_chars.tocsc())print"Xgb,CharLevelVectors:",accuracy#输出结果Xgb,CountVectors:

0.6324Xgb,WordLevelTF-IDF:

0.6364Xgb,CharLevelVectors:

0.65483.6浅层神经网络神经网络被设计成与生物神经元和神经系统类似的数学模型，这些模型用于发现被标注数据中存在的复杂模式和关系。一个浅层神经网络主要包含三层神经元-输入层、隐藏层、输出层。如果想了解更多关于浅层神经网络，请访问：/blog/2017/05/neural-network-from-scratch-in-python-and-r/defcreate_model_architecture(input_size):#createinputlayer

input_layer=layers.Input((input_size,),sparse=True)#createhiddenlayerhidden_layer=layers.Dense(100,activation="relu")(input_layer)#createoutputlayeroutput_layer=layers.Dense(1,activation="sigmoid")(hidden_layer)classifier=models.Model(inputs=input_layer,outputs=output_layer)pile(optimizer=optimizers.Adam(),loss='binary_crossentropy')returnclassifier

classifier=create_model_architecture(xtrain_tfidf_ngram.shape[1])accuracy=train_model(classifier,xtrain_tfidf_ngram,train_y,xvalid_tfidf_ngram,is_neural_net=True)print"NN,NgramLevelTFIDFVectors",

accuracy#输出结果：Epoch1/17500/7500[==============================]-1s67us/step-loss:0.6909NN,NgramLevelTFIDFVectors0.52963.7深层神经网络深层神经网络是更复杂的神经网络，其中隐藏层执行比简单Sigmoid或Relu激活函数更复杂的操作。不同类型的深层学习模型都可以应用于文本分类问题。卷积神经网络卷积神经网络中，输入层上的卷积用来计算输出。本地连接结果中，每一个输入单元都会连接到输出神经元上。每一层网络都应用不同的滤波器（filter）并组合它们的结果。如果想了解更多关于卷积神经网络，请访问：/blog/2017/06/architecture-of-convolutional-neural-networks-simplified-demystified/defcreate_cnn():#AddanInputLayerinput_layer=layers.Input((70,))#AddthewordembeddingLayerembedding_layer=layers.Embedding(len(word_index)+1,300,weights=[embedding_matrix],trainable=False)(input_layer)embedding_layer=layers.SpatialDropout1D(0.3)(embedding_layer)#AddtheconvolutionalLayerconv_layer=layers.Convolution1D(100,3,activation="relu")(embedding_layer)#AddthepoolingLayerpooling_layer=layers.GlobalMaxPool1D()(conv_layer)#AddtheoutputLayersoutput_layer1=layers.Dense(50,activation="relu")(pooling_layer)output_layer1=layers.Dropout(0.25)(output_layer1)output_layer2=layers.Dense(1,activation="sigmoid")(output_layer1)#Compilethemodelmodel=models.Model(inputs=input_layer,outputs=output_layer2)pile(optimizer=optimizers.Adam(),loss='binary_crossentropy')returnmodelclassifier=create_cnn()accuracy=train_model(classifier,train_seq_x,train_y,valid_seq_x,is_neural_net=True)print"CNN,WordEmbeddings",

accuracy#输出结果Epoch1/17500/7500[==============================]-12s2ms/step-loss:0.5847CNN,WordEmbeddings0.5296循环神经网络-LSTM与前馈神经网络不同，前馈神经网络的激活输出仅在一个方向上传播，而循环神经网络的激活输出在两个方向传播（从输入到输出，从输出到输入）。因此在神经网络架构中产生循环，充当神经元的“记忆状态”，这种状态使神经元能够记住迄今为止学到的东西。RNN中的记忆状态优于传统的神经网络，但是被称为梯度弥散的问题也因这种架构而产生。这个问题导致当网络有很多层的时候，很难学习和调整前面网络层的参数。为了解决这个问题，开发了称为LSTM（LongShortTermMemory）模型的新型RNN：如果想了解更多关于LSTM，请访问：/blog/2017/12/fundamentals-of-deep-learning-introduction-to-lstm/defcreate_rnn_lstm():#AddanInputLayerinput_layer=layers.Input((70,))#AddthewordembeddingLayerembedding_layer=layers.Embedding(len(word_index)+1,300,weights=[embedding_matrix],trainable=False)(input_layer)embedding_layer=layers.SpatialDropout1D(0.3)(embedding_layer)#AddtheLSTMLayerlstm_layer=layers.LSTM(100)(embedding_layer)#AddtheoutputLayersoutput_layer1=layers.Dense(50,activation="relu")(lstm_layer)output_layer1=layers.Dropout(0.25)(output_layer1)output_layer2=layers.Dense(1,activation="sigmoid")(output_layer1)#Compilethemodelmodel=models.Model(inputs=input_layer,outputs=output_layer2)pile(optimizer=optimizers.Adam(),loss='binary_crossentropy')returnmodelclassifier=create_rnn_lstm()accuracy=train_model(classifier,train_seq_x,train_y,valid_seq_x,is_neural_net=True)print"RNN-LSTM,WordEmbeddings",

accuracy#输出结果Epoch1/17500/7500[==============================]-22s3ms/step-loss:0.6899RNN-LSTM,WordEmbeddings0.5124循环神经网络-GRU门控递归单元是另一种形式的递归神经网络,我们在网络中添加一个GRU层来代替LSTM。defcreate_rnn_gru():#AddanInputLayerinput_layer=layers.Input((70,))#AddthewordembeddingLayerembedding_layer=layers.Embedding(len(word_index)+1,300,weights=[embedding_matrix],trainable=False)(input_layer)embedding_layer=layers.SpatialDropout1D(0.3)(embedding_layer)#AddtheGRULayerlstm_layer=layers.GRU(100)(embedding_layer)#AddtheoutputLayersoutput_layer1=layers.Dense(50,activation="relu")(lstm_layer)output_layer1=layers.Dropout(0.25)(output_layer1)output_layer2=layers.Dense(1,activation="sigmoid")(output_layer1)#Compilethemodelmodel=models.Model(inputs=input_layer,outputs=output_layer2)pile(optimizer=optimizers.Adam(),loss='binary_crossentropy')returnmodelclassifier=create_rnn_gru()accuracy=train_model(classifier,train_seq_x,train_y,valid_seq_x,is_neural_net=True)print"RNN-GRU,WordEmbeddings",

accuracy#输出结果Epoch1/17500/7500[==============================]-19s3ms/step-loss:0.6898RNN-GRU,WordEmbeddings0.5124双向RNNRNN层也可以被封装在双向层中，我们把GRU层封装在双向RNN网络中。defcreate_bidirectional_rnn():#AddanInputLayerinput_layer=layers.Input((70,))#AddthewordembeddingLayerembedding_layer=layers.Embedding(len(word_index)+1,300,weights=[embedding_matrix],trainable=False)(input_layer)embedding_layer=layers.SpatialDropout1D(0.3)(embedding_layer)#AddtheLSTMLayerlstm_layer=layers.Bidirectional(layers.GRU(100))(embedding_layer)#AddtheoutputLayersoutput_layer1=layers.Dense(50,activation="relu")(lstm_layer)output_layer1=layers.Dropout(0.25)(output_layer1)output_layer2=layers.Dense(1,activation="sigmoid")(output_layer1)#Compilethemodelmodel=models.Model(inputs=input_layer,outputs=output_layer2)pile(optimizer=optimizers.Adam(),loss='binary_crossentropy')returnmodelclassifier=create_bidirectional_rnn()accuracy=train_model(classifier,train_seq_x,train_y,valid_seq_x,is_neural_net=True)print"RNN-Bidirectional,WordEmbeddings",

accuracy#输出结果Epoch1/17500/7500[==============================]-32s4ms/step-loss:0.6889RNN-Bidirectional,WordEmbeddings0.5124循环卷积神经网络如果基本的架构已经尝试过，则可以尝试这些层的不同变体，如递归卷积神