keras 文本分类 LSTM

首先，对需要导入的库进行导入，读入数据后，用jieba来进行中文分词

# encoding: utf-8


#载入接下来分析用的库
import pandas as pd
import numpy as np
import xgboost as xgb
from tqdm import tqdm
from sklearn.svm import SVC
from keras.models import Sequential
from keras.layers.recurrent import LSTM, GRU
from keras.layers.core import Dense, Activation, Dropout
from keras.layers.embeddings import Embedding
from keras.layers.normalization import BatchNormalization
from keras.utils import np_utils
from sklearn import preprocessing, decomposition, model_selection, metrics, pipeline
from sklearn.model_selection import GridSearchCV
from sklearn.feature_extraction.text import TfidfVectorizer, CountVectorizer
from sklearn.decomposition import TruncatedSVD
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
from sklearn.naive_bayes import MultinomialNB
from keras.layers import GlobalMaxPooling1D, Conv1D, MaxPooling1D, Flatten, Bidirectional, SpatialDropout1D
from keras.preprocessing import sequence, text
from keras.callbacks import EarlyStopping
from nltk import word_tokenize


text = pd.read_csv('./competeDataForA.csv',sep = '\t', encoding ='utf-8')
test = pd.read_csv('./evaluationDataForA.csv',sep = '\t', encoding ='utf-8')
# print(text['id'].head())
# print(text['ocr'].head())
# print(text['label'].head())

print (text.info())

print (text.label.unique())


import jieba
# jieba.enable_parallel() #并行分词开启
text['文本分词'] = text['ocr'].apply(lambda i:jieba.cut(i) )
text['文本分词'] =[' '.join(i) for i in text['文本分词']]

test['文本分词'] = test['ocr'].apply(lambda i:jieba.cut(i) )
test['文本分词'] =[' '.join(i) for i in test['文本分词']]


print (text.head())


lbl_enc = preprocessing.LabelEncoder()
y = lbl_enc.fit_transform(text.label.values)

xtrain, xvalid, ytrain, yvalid = train_test_split(text.文本分词.values, y, 
                                                  stratify=y, 
                                                  random_state=42, 
                                                  test_size=0.1, shuffle=True)
print (xtrain.shape)
print (xvalid.shape)

xtest = test.文本分词.values


X=text['文本分词']

X=[i.split() for i in X]
X[:2]

然后调用Keras对文本进行序列化：

设置最大长度为500，多余值填0；

# ##################  LSTM 尝试  ##############################
# # 使用 keras tokenizer
from keras.preprocessing import sequence, text
token = text.Tokenizer(num_words=None)
max_len = 500

token.fit_on_texts(list(xtrain) + list(xvalid))
xtrain_seq = token.texts_to_sequences(xtrain)
xvalid_seq = token.texts_to_sequences(xvalid)
xtest_seq = token.texts_to_sequences(xtest)

#对文本序列进行zero填充
xtrain_pad = sequence.pad_sequences(xtrain_seq, maxlen=max_len)
xvalid_pad = sequence.pad_sequences(xvalid_seq, maxlen=max_len)
xtest_pad = sequence.pad_sequences(xtest_seq, maxlen=max_len)

word_index = token.word_index

import gensim

model = gensim.models.Word2Vec(X,min_count =5,window =8,size=100)   # X是经分词后的文本构成的list，也就是tokens的列表的列表
embeddings_index = dict(zip(model.wv.index2word, model.wv.vectors))

print('Found %s word vectors.' % len(embeddings_index))

print (len(word_index))
embedding_matrix = np.zeros((len(word_index) + 1, 100))
for word, i in tqdm(word_index.items()):
    embedding_vector = embeddings_index.get(word)
    if embedding_vector is not None:
        embedding_matrix[i] = embedding_vector

# 基于前面训练的Word2vec词向量，使用1个两层的LSTM模型
ytrain_enc = np_utils.to_categorical(ytrain)
yvalid_enc = np_utils.to_categorical(yvalid)

model = Sequential()
model.add(Embedding(len(word_index) + 1,
                     100,
                     weights=[embedding_matrix],
                     input_length=max_len,
                     trainable=False))
model.add(SpatialDropout1D(0.3))
model.add(LSTM(100, dropout=0.3, recurrent_dropout=0.3))

model.add(Dense(1024, activation='relu'))
model.add(Dropout(0.8))

model.add(Dense(1024, activation='relu'))
model.add(Dropout(0.8))

model.add(Dense(2))
model.add(Activation('softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adam')

#在模型拟合时，使用early stopping这个回调函数（Callback Function）
earlystop = EarlyStopping(monitor='val_loss', min_delta=0, patience=3, verbose=0, mode='auto')
model.fit(xtrain_pad, y=ytrain_enc, batch_size=512, epochs=35, 
          verbose=1, validation_data=(xvalid_pad, yvalid_enc), callbacks=[earlystop])

pred_lstm_2 = model.predict_classes(xtest_pad)
pred_lstm_2 = pd.DataFrame(pred_lstm_2)
pred_lstm_2_res = pd.concat([test['id'],pred_lstm_2], axis=1)
pred_lstm_2_res.rename(columns={0:'label'},inplace=True)
pred_lstm_2_res.to_csv('pred_lstm_2_res.csv',sep = ',', index = False, encoding = 'utf-8')

LSTM有三种dropout:

model.add(LSTM(100, dropout=0.2, recurrent_dropout=0.2))

第一个dropout是x和hidden之间的dropout,第二个是hidden-hidden之间的dropout

第三个是层-层之间的dropout

model.add(Embedding(top_words, embedding_vecor_length, input_length=max_review_length))
model.add(Dropout(0.2))
model.add(LSTM(100))
model.add(Dropout(0.2))

0. 前言

Tokenizer是一个用于向量化文本，或将文本转换为序列（即单个字词以及对应下标构成的列表，从1算起）的类。是用来文本预处理的第一步：分词。结合简单形象的例子会更加好理解些。

1. 语法

官方语法如下1：

Code.1.1 分词器Tokenizer语法

keras.preprocessing.text.Tokenizer(num_words=None,
                                   filters='!"#$%&()*+,-./:;<=>?@[\]^_`{|}~\t\n',
                                   lower=True,
                                   split=" ",
                                   char_level=False)

1.1 构造参数
num_words：默认是None处理所有字词，但是如果设置成一个整数，那么最后返回的是最常见的、出现频率最高的num_words个字词。
filters：过滤一些特殊字符，默认上文的写法就可以了。
lower：全部转为小写
split：字符串，单词的分隔符，如空格

1.2 返回值
字符串列表

1.3 类方法
下面是相关的类方法，部分示例在下一节中均有描述应用。

keras 文本分类 LSTM

1.4 属性

document_count 处理的文档数量
word_index 一个dict，保存所有word对应的编号id，从1开始
word_counts 一个dict，保存每个word在所有文档中出现的次数
word_docs 一个dict，保存每个word出现的文档的数量
index_docs 一个dict，保存word的id出现的文档的数量

word_counts:字典，将单词（字符串）映射为它们在训练期间出现的次数。仅在调用fit_on_texts之后设置。
word_docs: 字典，将单词（字符串）映射为它们在训练期间所出现的文档或文本的数量。仅在调用fit_on_texts之后设置。
word_index: 字典，将单词（字符串）映射为它们的排名或者索引。仅在调用fit_on_texts之后设置。
document_count: 整数。分词器被训练的文档（文本或者序列）数量。仅在调用fit_on_texts或fit_on_sequences之后设置。

2. 简单示例

Code.2.1 简单示例

>>>from keras.preprocessing.text import Tokenizer
Using TensorFlow backend.

#  创建分词器 Tokenizer 对象
>>>tokenizer = Tokenizer()

#  text
>>>text = ["今天 北京 下 雨 了", "我 今天 加班 了"]

#  fit_on_texts 方法
>>>tokenizer.fit_on_texts(text)

#  word_counts属性
>>>tokenizer.word_counts
OrderedDict([('今天', 2),
             ('北京', 1),
             ('下', 1),
             ('雨', 1),
             ('了', 2),
             ('我', 1),
             ('加班', 1)])

#  word_docs属性
>>>tokenizer.word_docs
defaultdict(int, {'下': 1, '北京': 1, '今天': 2, '雨': 1, '了': 2, '我': 1, '加班': 1})

#  word_index属性
>>>tokenizer.word_index
{'今天': 1, '了': 2, '北京': 3, '下': 4, '雨': 5, '我': 6, '加班': 7}

#  document_count属性
>>>tokenizer.document_count
2

3. 常用示例

还以上面的tokenizer对象为基础，经常会使用texts_to_sequences()方法和序列预处理方法 keras.preprocessing.sequence.pad_sequences一起使用

有关pad_sequences用法见python函数——序列预处理pad_sequences()序列填充

Code.3.1 常用示例

>>>tokenizer.texts_to_sequences(["下 雨 我 加班"])
[[4, 5, 6, 7]]

>>>keras.preprocessing.sequence.pad_sequences(tokenizer.texts_to_sequences(["下 雨 我 加班"]), maxlen=20)
array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 5, 6, 7]],dtype=int32)

Keras基本使用方法：

https://blog.csdn.net/qq_41185868/article/details/84067803

Python中利用LSTM模型进行时间序列预测分析

http://www.cnblogs.com/arkenstone/p/5794063.html

参考：https://blog.csdn.net/wcy23580/article/details/84885734

https://zhuanlan.zhihu.com/p/50657430

本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：keras 文本分类 LSTM - Python技术站