利用卷积神经网络（cnn）实现文本分类.docx

《利用卷积神经网络（cnn）实现文本分类.docx》由会员分享，可在线阅读，更多相关《利用卷积神经网络（cnn）实现文本分类.docx（7页珍藏版）》请在淘文阁 - 分享文档赚钱的网站上搜索。

1、利 卷 积 神 经 络 （ cnn） 实 现 本 分 类 卷 积 神 经 络 在 情 感 分 析 中 取 得 了 很 好 的 成 果 ， 相 于 之 前 浅 层 的 机 器 学 习 法 如 NB、 SVM效 果 更 好 ， 特 别 实 在 数 据 集 较 的 情 况 下 ， 并且 CNN不 我 们 动 去 提 取 特 征 ， 原 浅 层 ML是 需 要 进 本 特 征 提 取 、 本 特 征 表 、 归 化 、 最 后 进 本 分 类 ， 本 特 征 提 取 主 要 可以 分 为 四 步 ： （ 1） ： 对 全 部 训 练 档 进 分 词 ， 由 这 些 词 作 为 向 量 的 维 数 来

2、表 本 ;（ 2） ： 统 计 每 类 档 中 所 有 出 现 的 词 语 及 其 频 率 ， 然 后 过 滤 ， 剔 除 停 词 和 单 字 词 ;（ 3） ： 统 计 每 类 内 出 现 词 语 的 总 词 频 ， 并 取 若 个 频 率 更 的 词 汇 作 为 这 类 的 特 征 词 集 ;（ 4） ： 去 除 每 类 别 中 都出 现 的 词 ， 合并 所 有 类 别 的 特 征 词 集 ， 形成 总 特 征 词 集 ， 最 后 得 到的 特 征 词 集 是 我 们 到的 特 征 集 合， 再 该集 合去 筛选测试集 中 的 特 征 。 本 的 特 征 表 是 利 TF-IDF公式来

3、计 算词 的 权值， 这 也充分 利 的 是 特 征 提 取 时提 取 的 特 征 来 计 算特 征 权值 的 ， 归 化 处理需 要 处理的 数 据 ， 经 过 处理后 限制在 定范围内 ， 经 过 处理后 ， 我 们 原 来 的 本 信息已经 抽象成 个 向 量 化 的 样本 集 ， 然 后 将样本集 和 训 练 好 的 模板进 相 似度计 算， 若 属于 该类 别 ， 则与其 他类 别 的 模板 件进 计 算， 直到分 进 相 应的 类 别 ， 这 是 浅 层 ML进 本 分 类的 式 ；CNN进 本 分 类 相 对 简单 些 ， 我 结合最 近做的 些 实 验总 结了 下 ： 在 利

4、CNN进 本 分 类 的 时候， 先要 将原 始 本 进 预处理， 主 要 还是 分 词 、 去 除 停 词 等， 然 后 对 预处理后 的 本 进 向 量 化 利 word2vec， 我 利 的 时word2vec中 的 skip-gram模型， 将搜狗数 据 集 表 为 了 200维 的 词 向 量 形式;转化 为 词 向 量 后 就可 以 将每 句话转化 为 个 矩阵的 形式， 这 样就跟利 CNN处理图像分 类 很 相 似;说 下 实 验， 我 的 实 验环境：# encoding=utf-from future import unicode_literalsimport tensor

5、flow as tf import numpyas npclass TextCNN(object):使 CNN 于 情 感 分 析 整个 CNN架构包括词 嵌层 ， 卷 积 层 ，max-pooling层 和 softmax层def init (self, sequence_length, num_classes,vocab_size,embedding_size, embedding_table, filter_sizes, num_filters, l2_reg_lambda=0.0):# 输， 输出 ， dropout的 placeholderself.input_x= tf.place

6、holder(tf.int32, None, sequence_length, name=input_x)self.input_y= tf.placeholder(tf.float32, None, num_classes, name=input_y) self.dropout_keep_prob = tf.placeholder(tf.float32, name=dropout_keep_prob)#eeping track of l2 regularization loss (optional) l2_loss = tf.constant(0.0)# 词 嵌层with tf.device(

7、/cpu:0), tf.name_scope(embedding):W = tf.Variable(embedding_table,name=W)#embedding_table就是 词 向 量 表 ， W还有 另 种简单 的 表 达#W=tf.Variable(vocab_size,embedding_size,-1.0,1.0),随机 初始化 这 个 词 向 量 表 ；self.embedded_chars = tf.nn.embedding_lookup(W, self.input_x)#这 个 tf.nn.embedding_lookup()的 作 就是 从词 向 量 表 中 去 找i

8、nput_x所 对 应的 词 向 量 ；self.embedded_chars_expanded = tf.expand_dims(self.embedded_chars, -1)tensorflow1.2、 gpu1050Ti、 Ubuntu16.04、 pycharm、 python2.7#由 于 CNN输 都 是 四 维 ， 所 以 在 最 后 维 添 加 个 维 度 ， 与 CNN的 输 维 度 对 照 起 来 。 # 成 卷 积 层 和max-pooling层pooled_outputs = for i, filter_size in enumerate(filter_sizes):

9、with tf.name_scope(conv-maxpool-%s % filter_size): # Convolution Layerfilter_shape = filter_size, embedding_size, 1, num_filtersW = tf.Variable(tf.truncated_normal(filter_shape, stddev=0.1), name=W) b = tf.Variable(tf.constant(0.1, shape=num_filters), name=b)conv = tf.nn.conv2d( self.embedded_chars_

10、expanded, W,strides=1, 1, 1, 1, padding=VALID, name=conv)# Applynonlinearity# h = tf.nn.relu(tf.nn.bias_add(conv, b), name=relu) h=tf.nn.relu6(tf.nn.bias_add(conv,b),name=relu)#axpooling over the outputs # pooled = tf.nn.max_pool(#h,#ksize=1, sequence_length - filter_size + 1, 1, 1,#strides=1, 1, 1,

11、 1, #padding=VALID, #name=pool)# pooled_outputs.append(pooled) pooled = tf.nn.avg_pool(h,ksize=1, sequence_length - filter_size + 1, 1, 1,strides=1, 1, 1, 1, padding=VALID, name=pool)pooled_outputs.append(pooled)# 将 max-pooling层 的 各 种 特 征 整 合 在 起 num_filters_total = num_filters * len(filter_sizes)se

12、lf.h_pool = tf.concat(pooled_outputs,3)self.h_pool_flat = tf.reshape(self.h_pool, -1, num_filters_total)# 添 加 全 连 接 层 ， 于 分 类with tf.name_scope(full-connection):W_fc1 = tf.Variable(tf.truncated_normal(num_filters_total,500, stddev=0.1) b_fc1 = tf.Variable(tf.constant(0.1,shape=500)self.h_fc1 = tf.nn

13、.relu6(tf.matmul(self.h_pool_flat, W_fc1) + b_fc1)# 添 加 dropout层 于 缓和 过拟化with tf.name_scope(dropout):# self.h_drop = tf.nn.dropout(self.h_pool_flat, self.dropout_keep_prob) self.h_drop = tf.nn.dropout(self.h_fc1, self.dropout_keep_prob)# 产 最 后 的 输 出和 预测with tf.name_scope(output):# W = tf.get_variabl

14、e( #W,#shape=num_filters_total, num_classes,#initializer=tf.contrib.layers.xavier_initializer() W = tf.get_variable(W,shape=500, num_classes, initializer=tf.contrib.layers.xavier_initializer()b = tf.Variable(tf.constant(0.1, shape=num_classes), name=b) l2_loss += tf.nn.l2_loss(W)l2_loss += tf.nn.l2_

15、loss(b)self.scores = tf.nn.xw_plus_b(self.h_drop, W, b, name=scores)self.scores = tf.nn.xw_plus_b(self.h_drop, W, b, name=scores)self.predictions = tf.argmax(self.scores, 1, name=predictions)定 义 模 型 的 损 失 函 数 with tf.name_scope(loss):losses = tf.nn.softmax_cross_entropy_with_logits(logits=self.score

16、s, labels=self.input_y) self.loss = tf.reduce_mean(losses) + l2_reg_lambda * l2_loss定 义 模 型 的 准 确 率 with tf.name_scope(accuracy):correct_predictions = tf.equal(self.predictions, tf.argmax(self.input_y, 1) self.accuracy = tf.reduce_mean(tf.cast(correct_predictions, float), name=accuracy)以 上 时 TextCNN

17、的 模 型 结 构 代 码 ， 然 后 开 始 进 train， 并 利summary和checkpoints来记录模 型 和训练时 的 参数 等等， 利折交叉验证来产准 确 率 ， 最后 利tensorboard查看accuracy、loss、w、b等等变化图;训练py的 代 码 ：/usr/bin/env python encoding=utf-8import tensorflow as tf import numpy as np import osimport time import datetimeimport data_loaderfrom cnn_graph import Text

18、CNN from tensorflow.contrib import learn from sklearn import cross_validation import preprocessingtf.global_variables伴随tensorflow的 summary和checkout=odelyperparameterstf.flags.DEFINE_integer(embedding_dim, 200, Dimensionality of character embedding (default: 128) tf.flags.DEFINE_string(filter_sizes,

19、3,4,5, Comma-separated filter sizes (default: 3,4,5) tf.flags.DEFINE_integer(num_filters, 40, Number of filters per filter size (default: 128) tf.flags.DEFINE_float(dropout_keep_prob, 0.5, Dropout keep probability (default: 0.5) tf.flags.DEFINE_float(l2_reg_lambda, 3.0, L2 regularizaion lambda (defa

20、ult: 0.0)Training parameterstf.flags.DEFINE_integer(batch_size, 50, Batch Size (default: 64) tf.flags.DEFINE_integer(num_epochs, 100, Number of training epochs (default: 200)tf.flags.DEFINE_integer(evaluate_every, 100, Evaluate model on dev set after this many steps (default: 100) tf.flags.DEFINE_in

21、teger(checkpoint_every, 100, Save model after this many steps (default: 100)isc Parameterstf.flags.DEFINE_boolean(allow_soft_placement, True, Allow device soft device placement) tf.flags.DEFINE_boolean(log_device_placement, False, Log placement of ops on devices)w2v件路径tf.flags.DEFINE_string(w2v_path

22、, ./w2v_model/retrain_vectors_100.bin, w2v file) tf.flags.DEFINE_string(file_dir,./data_process/jd,train/test dataSet)FLAGS = tf.flags.FLAGS FLAGS._parse_flags() print(nParameters:)for attr, value in sorted(FLAGS. flags.items(): print(=.format(attr.upper(), value)print()Data Preparatopn=Load dataLoa

23、d data print(Loading data.)files = reviews.neg,reviews.pos加 载 所 有 的 未 切 分 的 数 据 x_text, y_labels,neg_examples,pos_examples = data_loader.load_data_and_labels(data_dir=FLAGS.file_dir,files=files,splitable=False)获 取 消 极 数 据 的2得 ,到 的 评 论 的 长 度 离 散 度 更 低 neg_accept_length = preprocessing.freq_factor(neg

24、_examples,percentage=0.8, drawable=False) neg_accept_length = item0 for item in neg_accept_lengthneg_examples = data_loader.load_data_by_length(neg_examples,neg_accept_length)获 取 积 极 数 据 的2得 ,到 的 评 论 的 长 度 离 散 度 更 低 pos_accept_length = preprocessing.freq_factor(pos_examples,percentage=0.8, drawable=

25、False) pos_accept_length = item0 for item in pos_accept_lengthpos_examples = data_loader.load_data_by_length(pos_examples,pos_accept_length)x_text = neg_examples + pos_examples neg_labels = 1,0 for _ in neg_examples pos_labels = 0,1 for _ in pos_examplesy_labels = np.concatenate(neg_labels,pos_label

26、s, axis=0) print(Loading data finish)uild vocabularymax_document_length = max(len(x.split( ) for x in x_text)最 长 的 句 的 长 度 print(max_document_length)vocab_processor = learn.preprocessing.VocabularyProcessor(max_document_length) x = np.array(list(vocab_processor.fit_transform(x_text)加 载 提前训练的w2v数 据 集

27、word_vecs = data_loader.load_bin_vec(fname=FLAGS.w2v_path, vocab=list(vocab_processor.vocabulary_._mapping),ksize=FLAGS.embedding_dim)加 载 嵌层的tableW = data_loader.get_W(word_vecs=word_vecs, vocab_ids_map=vocab_processor.vocabulary_._mapping, k=FLAGS.embedding_dim,is_rand=False)随机化数 据 np.random.seed(1

28、0)shuffle_indices = np.random.permutation(np.arange(len(y_labels) x_shuffled = xshuffle_indicesy_shuffled = y_labelsshuffle_indicesout_path = os.path.abspath(os.path.join(os.path.curdir, runs,parameters) parameters = 新全连接+jd数 据 +10n embedding_dim: ,n filter_sizes:,n num_filters:,n dropout_keep_prob:

29、,n l2_reg_lambda:,n num_epochs:,n batch_size:.format(FLAGS.embedding_dim,FLAGS.filter_sizes,FLAGS.num_filters, FLAGS.dropout_keep_prob,FLAGS.l2_reg_lambda,FLAGS.num_epochs, FLAGS.batch_size)open(out_path, w).write(parameters)raining=def train(X_train, X_dev, x_test, y_train, y_dev, y_test): with tf.

30、Graph().as_default():session_conf = tf.ConfigProto( allow_soft_placement=FLAGS.allow_soft_placement, log_device_placement=FLAGS.log_device_placement) sess = tf.Session(config=session_conf)log_device_placement=FLAGS.log_device_placement) sess = tf.Session(config=session_conf)with sess.as_default(): c

31、nn = TextCNN(sequence_length=max_document_length, num_classes=2, vocab_size=len(vocab_processor.vocabulary_), embedding_size=FLAGS.embedding_dim, embedding_table=W,filter_sizes=list(map(int, FLAGS.filter_sizes.split(,), num_filters=FLAGS.num_filters, l2_reg_lambda=FLAGS.l2_reg_lambda)efine Training

32、procedureglobal_step = tf.Variable(0, name=global_step, trainable=False) optimizer = tf.train.AdamOptimizer(1e-3)grads_and_vars = pute_gradients(cnn.loss)train_op = optimizer.apply_gradients(grads_and_vars, global_step=global_step)eep track of gradient values and sparsity (optional) grad_summaries =

33、 for g, v in grads_and_vars: if g is not None:grad_hist_summary = tf.summary.histogram(/grad/hist.format(v.name), g) sparsity_summary = tf.summary.scalar(/grad/sparsity.format(v.name), tf.nn.zero_fraction(g) grad_summaries.append(grad_hist_summary)grad_summaries.append(sparsity_summary) grad_summari

34、es_merged = tf.summary.merge(grad_summaries)Output directory for models and summaries timestamp = str(int(time.time()out_dir = os.path.abspath(os.path.join(os.path.curdir, runs, timestamp) print(Writing to n.format(out_dir)Summaries for loss and accuracy loss_summary = tf.summary.scalar(loss, cnn.lo

35、ss)acc_summary = tf.summary.scalar(accuracy, cnn.accuracy)Train Summariestrain_summary_op = tf.summary.merge(loss_summary, acc_summary, grad_summaries_merged) train_summary_dir = os.path.join(out_dir, summaries, train)train_summary_writer = tf.summary.FileWriter(train_summary_dir, sess.graph)ev summ

36、ariesdev_summary_op = tf.summary.merge(loss_summary, acc_summary) dev_summary_dir = os.path.join(out_dir, summaries, dev) dev_summary_writer = tf.summary.FileWriter(dev_summary_dir, sess.graph)Checkpoint directory. Tensorflow assumes this directory already exists so we need to create it checkpoint_d

37、ir = os.path.abspath(os.path.join(out_dir, checkpoints)checkpoint_prefix = os.path.join(checkpoint_dir, model) if not os.path.exists(checkpoint_dir):os.makedirs(checkpoint_dir)saver = tf.train.Saver(tf.global_variables()Write vocabulary vocab_processor.save(os.path.join(out_dir, vocab)nitialize all

38、variables sess.run(tf.initialize_all_variables()sess.run(tf.global_variables_initializer()def train_step(x_batch, y_batch): A single training step feed_dict = cnn.input_x: x_batch, cnn.input_y: y_batch,cnn.dropout_keep_prob: FLAGS.dropout_keep_prob_, step, summaries, loss, accuracy = sess.run(train_

39、op, global_step, train_summary_op, cnn.loss, cnn.accuracy, feed_dict)_, step, loss, accuracy = sess.run(train_op, global_step, cnn.loss, cnn.accuracy, feed_dict)time_str = datetime.datetime.now().isoformat()print(: step , loss :g, acc :g.format(time_str, step, loss, accuracy) train_summary_writer.ad

40、d_summary(summaries, step)def dev_step(x_batch, y_batch, writer=None): Evaluates model on a dev set feed_dict = cnn.input_x: x_batch, cnn.input_y: y_batch,cnn.dropout_keep_prob: 1.0step, summaries, loss, accuracy = sess.run(global_step, dev_summary_op, cnn.loss, cnn.accuracy, feed_dict)step, loss, a

41、ccuracy = sess.run( global_step, cnn.loss, cnn.accuracy, feed_dict)time_str = datetime.datetime.now().isoformat()print(: step , loss :g, acc :g.format(time_str, step, loss, accuracy) if writer:writer.add_summary(summaries, step)Generate batchesbatches = data_loader.batch_iter(list(zip(X_train, y_tra

42、in), FLAGS.batch_size, FLAGS.num_epochs) raining loop. For each batch.for batch in batches:x_batch, y_batch = zip(*batch) train_step(x_batch, y_batch)current_step = tf.train.global_step(sess, global_step) if current_step % FLAGS.evaluate_every = 0:print(nEvaluation:)dev_step(X_dev, y_dev, writer=dev

43、_summary_writer) dev_step(X_dev, y_dev, writer=None)print()if current_step % FLAGS.checkpoint_every = 0:path = saver.save(sess, checkpoint_prefix, global_step=current_step) print(Saved model checkpoint to n.format(path)est loopGenerate batches for one epochbatches = data_loader.batch_iter(list(x_tes

44、t), FLAGS.batch_size, 1, shuffle=False) ollect the predictions hereall_predictions = for x_test_batch in batches:batch_predictions = sess.run(cnn.predictions, cnn.input_x: x_test_batch, cnn.dropout_keep_prob:1.0) all_predictions = np.concatenate(all_predictions, batch_predictions)correct_predictions

45、 = float(sum(all_predictions = np.argmax(y_test,axis=1)all_predictions = np.argmax(y_test,axis=1)print(Total number of test examples: .format(len(y_test) print(Accuracy: :g.format(correct_predictions / float(len(y_test)open(os.path.join(out_dir,test),a).write(Accuracy: :g.format(correct_predictions / float(len(y_test) out_path = os.path.abspath(os.path.join(os.path.curdir, runs,test) open(out_path,a).write(:g,.forma