tensorflow自然语言处理-词袋模型文本分类

写在前面

  • 态度决定高度!让优秀成为一种习惯!
  • 世界上没有什么事儿是加一次班解决不了的,如果有,就加两次!(- - -茂强)

词袋模型文本分类

  • 数据准备
    如图数据
数据准备
  • 数据清晰
    数据读取与清晰,这里只过滤出中文,并且两个字以上的词
    target = [] #存储句子的正负面标签,1代表正面,0代表负面
    texts = [] #存储句子
    with open("c:/traindatav.txt", "r", encoding="utf-8") as f:
    for line in f.readlines():
    text = line.split(" => ")
    if len(text) == 2:
    lable = text[0].strip()
    sentence = " ".join([w for w in text[1].split(" ") if re.match("[\u4e00-\u9fa5]+", w) and len(w) >= 2])
    if lable == "正面":
    target.append(1)
    else:
    target.append(0)
    texts.append(sentence)
    最后得到texts和target连个list
texts
target
  • 句子的长度不能过长,因此我们需要确定一个最大的句子长度,这样我们需要看一下句子长度的分布是如何的

    text_lengths = [len(x.split()) for x in texts]
    text_lengths = [x for x in text_lengths if x < 100]
    plt.hist(text_lengths, bins=25)
    plt.title('Histogram of # of Words in Texts')
    plt.show()
    

如图:

句子长度分布

从图上可以看出,长度取60时已经涵盖了大部分的句子
因此声明

  sentence_size = 60
  min_word_freq = 3
  • 清晰地数据转化成tensorflow能够接受的数据,这一点,在tensorflow中在 learn.preprocessing包下有一个内置函数VocabularyProcessor()
    vocab_processor = learn.preprocessing.VocabularyProcessor(sentence_size, min_frequency=min_word_freq)
    vocab_processor.fit_transform(texts)
    vocab_processor.vocabulary_
    我们来看一下,vocab_processor.vocabulary_中到底是什么
数据转化

其中_ferq这个就是词频的统计dict

_freq

其中_mapping是一个对每个词编辑一个索引

_mapping

还有一个

_reverse_mapping

就是上一个的reverse,只不过用了list表示
其他的就不解释了

  • 把数据集分成训练集于测试集
    train_indices = np.random.choice(len(texts), round(len(texts)*0.8), replace=False)
    test_indices = np.array(list(set(range(len(texts))) - set(train_indices)))
    texts_train = [x for ix, x in enumerate(texts) if ix in train_indices]
    texts_test = [x for ix, x in enumerate(texts) if ix in test_indices]
    target_train = [x for ix, x in enumerate(target) if ix in train_indices]
    target_test = [x for ix, x in enumerate(target) if ix in test_indices]
    解释一个数据内容
texts_train
target_train
  • 声明一个embedding矩阵
    identity_mat = tf.diag(tf.ones(shape=[embedding_size]))

  • 然后声明各logistic回归的变量和placeholder
    A = tf.Variable(tf.random_normal(shape=[embedding_size,1]))
    b = tf.Variable(tf.random_normal(shape=[1,1]))
    # Initialize placeholders
    x_data = tf.placeholder(shape=[sentence_size], dtype=tf.int32)
    y_target = tf.placeholder(shape=[1, 1], dtype=tf.float32)

  • 不得不说的tf.nn.embedding_lookup函数
    其实embedding_lookup的原理很简单,相当于在np.array中直接采用下标数组获取数据。细节是返回的tensor的dtype和传入的被查询的tensor的dtype保持一致;和ids的dtype无关。
    下面看个例子

    import tensorflow as tf 
    import numpy as np
    sess = tf.InteractiveSession()
    mat1 = tf.reshape(tf.range(1, 10, name="m1"), shape=[3, 3])
     [[1, 2, 3],
     [4, 5, 6],
     [7, 8, 9]]
    ids = [[1,2], [0,1]]
    res = tf.nn.embedding_lookup(mat1, ids)
    res.eval()
    
结果

从上边的例子看出, ids = [[1,2], [0,1]]决定要取矩阵的哪一行数据

  • 不得不说的tf.reduce_sum函数
    还是老规矩,先看例子

    # 'x' is [[1, 1, 1]
    #         [1, 1, 1]]
    tf.reduce_sum(x) ==> 6
    tf.reduce_sum(x, 0) ==> [2, 2, 2]
    tf.reduce_sum(x, 1) ==> [3, 3]
    tf.reduce_sum(x, 1, keep_dims=True) ==> [[3], [3]]
    tf.reduce_sum(x, [0, 1]) ==> 6
    

例子看完我想你就明白了吧

  • 下面就是如何把一个句子转成向量了
    x_embed = tf.nn.embedding_lookup(identity_mat, x_data)
    x_col_sums = tf.reduce_sum(x_embed, 0)
    首先是根据diag生成的one-hot矩阵,根据输入的x_data(也就是每个句子中每个词的索引向量),比如“我们 是 中国人”在vocab_processor.vocabulary_中的_mapping中的索引分别是[20, 3, 134]
    那么embedding_lookup会从diag矩阵中找到对应的行号(20,3,134)行的数据,也就是每个词的词向量,然后再reduce_sum注意参数0我们可以从以上例子中看到,其实就是把每个词的向量按index相加,就生成该句子的向量,而对应的20,3,134列的数字就是1其他都是0
    所以x_col_sums就代表一个句子向量

    # 't' is a tensor of shape [2]
    shape(expand_dims(t, 0)) ==> [1, 2]
    shape(expand_dims(t, 1)) ==> [2, 1]
    shape(expand_dims(t, -1)) ==> [2, 1]
    
    # 't2' is a tensor of shape [2, 3, 5]
    shape(expand_dims(t2, 0)) ==> [1, 2, 3, 5]
    shape(expand_dims(t2, 2)) ==> [2, 3, 1, 5]
    shape(expand_dims(t2, 3)) ==> [2, 3, 5, 1]
    

如果看不明白,就用一个例子来看
labels = [1,2,3]
x = tf.expand_dims(labels, 0)
[[1 2 3]] #结果增加了一个维度
x = tf.expand_dims(labels, 1)
[[1]
[2]
[3]]
看了上边的例子就能够有个理解了

  • 变换与计算
    x_col_sums_2D = tf.expand_dims(x_col_sums, 0)
    model_output = tf.add(tf.matmul(x_col_sums_2D, A), b)
    首先把x_col_sums按照0方式变换增加一维,主要是为了矩阵运算,然后计算y=AX+B

  • 然后定义损失函数
    loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(model_output, y_target))
    其实就是逻辑回归表达式

  • 然后定义激活函数
    prediction = tf.sigmoid(model_output)

  • 接下来就是优化算法
    my_opt = tf.train.GradientDescentOptimizer(0.001)
    train_step = my_opt.minimize(loss)

  • 紧接着就是参数初始化
    init = tf.initialize_all_variables()
    sess.run(init)

  • 接着对所有的句子进行迭代训练
    loss_vec = []
    train_acc_all = []
    train_acc_avg = []
    for ix, t in enumerate(vocab_processor.fit_transform(texts_train)):y_data = [[target_train[ix]]]
    sess.run(train_step, feed_dict={x_data: t, y_target: y_data})
    temp_loss = sess.run(loss, feed_dict={x_data: t, y_target: y_data})
    loss_vec.append(temp_loss)
    if (ix+1)%10==0:
    print('Training Observation #' + str(ix+1) + ': Loss = ' +str(temp_loss))
    # Keep trailing average of past 50 observations accuracy
    # Get prediction of single observation
    [[temp_pred]] = sess.run(prediction, feed_dict={x_data:t, y_target:y_data})
    # Get True/False if prediction is accurate
    train_acc_temp = target_train[ix]==np.round(temp_pred)
    train_acc_all.append(train_acc_temp)
    if len(train_acc_all) >= 50:
    train_acc_avg.append(np.mean(train_acc_all[-50:]))
    loss_vec存放的是每次训练的损失值,train_acc_all存放的是所有的acc值,train_acc_avg存放的是每50次的平均acc值
    声明一点,这里是对每一个句子进行迭代的,而不是批计算的

  • 最后就是测试
    print('Getting Test Set Accuracy')
    test_acc_all = []
    for ix, t in enumerate(vocab_processor.fit_transform(texts_test)):
    y_data = [[target_test[ix]]]
    if (ix+1)%50==0:
    print('Test Observation #' + str(ix+1))
    # Keep trailing average of past 50 observations accuracy
    # Get prediction of single observation
    [[temp_pred]] = sess.run(prediction, feed_dict={x_data:t,y_target:y_data})
    # Get True/False if prediction is accurate
    test_acc_temp = target_test[ix]==np.round(temp_pred)
    test_acc_all.append(test_acc_temp)
    print('\nOverall Test Accuracy: {}'.format(np.mean(test_acc_all)))

推荐阅读更多精彩内容