Text Classification 代码学习笔记

def main(unused_argv):
    
    # Prepare training and testing data
    # ...
    
    
    # Process vocabulary
    # ...
    

    # Build model
    # ...

    # Train
    # ...
    
    # Predict.
    # ...
    
    # Socre
    # ...

import ... # 省略导包

# 官方的下载数据，以及通过pandas读取数据的代码
dbpedia = tf.contrib.learn.datasets.load_dataset(
    'dbpedia',
    test_with_fake_data=FLAGS.test_with_fake_data)

x_train = pd.Series(dbpedia.train.data[:, 1])
y_train = pd.Series(dbpedia.train.target)
x_test = pd.Series(dbpedia.test.data[:, 1])
y_test = pd.Series(dbpedia.test.target)

names = ["class", "title", "content"] # 描述中 数据有三项 类别 标题 和内容

# 读取 csv 文件 并且利用我们制定的 names 来分组
train_csv = pd.read_csv("./dbpedia_data/dbpedia_csv/train.csv", names=names)
test_csv = pd.read_csv("./dbpedia_data/dbpedia_csv/test.csv", names=names)

# 通过指定的 name 拿到我们要的 x:content 和 y:class 
x_train = pd.Series(train_csv["content"])
y_train = pd.Series(train_csv["class"])
x_test = pd.Series(test_csv["content"])
y_test = pd.Series(test_csv["class"])

vocab_processor = tf.contrib.learn.preprocessing.VocabularyProcessor(
    MAX_DOCUMENT_LENGTH)

x_transform_train = vocab_processor.fit_transform(x_train)
x_transform_test = vocab_processor.transform(x_test)

x_train = np.array(list(x_transform_train))
x_test = np.array(list(x_transform_test))

global n_words
n_words = len(vocab_processor.vocabulary_)
print('Total words: %d' % n_words)

# 注意这两个函数不一样哟 一个是 fit_transform 一个是 transform
x_transform_train = vocab_processor.fit_transform(x_train)
x_transform_test = vocab_processor.transform(x_test)

x_text = ['This is a cat','This must be boy', 'This is a a dog']
vocab_pro = VocabularyProcessor(6)
x = np.array(list(vocab_pro.fit_transform(x_text)))
print(x)

def rnn_model(features, labels, mode):
    """用RNN模型来预测文本的类别"""
    
    # 词语索引 -> 词嵌入 embedding 
    word_vectors = tf.contrib.layers.embed_sequence(
        features[WORDS_FEATURE], vocab_size=n_words, embed_dim=EMBEDDING_SIZE)

    # 展平向量  word_list 变成 [batch_size, EMBEDDING_SIZE] 形状的一个 tensor
    word_list = tf.unstack(word_vectors, axis=1)

    # 用嵌入层数量(也就是对应的GRU单元个数) 创建GRU单元
    cell = tf.contrib.rnn.GRUCell(EMBEDDING_SIZE)

    # 创建一个展平的 RNN 网络(其长度等于我们的MAX_DOCUMENT_LENGTH),并且把 word_list 作为输入
    _, encoding = tf.contrib.rnn.static_rnn(cell, word_list, dtype=tf.float32)

    # 得到通过 RNN 编码之后的一组向量(logits)，然后利用 softmax 来变成一个归一化概率的向量，从而预测对应的类别
    logits = tf.layers.dense(encoding, MAX_LABEL, activation=None)
    return estimator_spec_for_softmax_classification(
        logits=logits, labels=labels, mode=mode)

def bag_of_words_model(features, labels, mode):
    """词袋模型，不考虑文本的顺序"""
    bow_column = tf.feature_column.categorical_column_with_identity(
        WORDS_FEATURE, num_buckets=n_words)

    bow_embedding_column = tf.feature_column.embedding_column(
        bow_column, dimension=EMBEDDING_SIZE)

    bow = tf.feature_column.input_layer(
        features,
        feature_columns=[bow_embedding_column])
    logits = tf.layers.dense(bow, MAX_LABEL, activation=None)

    return estimator_spec_for_softmax_classification(
        logits=logits, labels=labels, mode=mode)

def estimator_spec_for_softmax_classification(
        logits, labels, mode):
    """Returns EstimatorSpec instance for softmax classification."""
    predicted_classes = tf.argmax(logits, 1)
    if mode == tf.estimator.ModeKeys.PREDICT # Predict 时候用         
        return tf.estimator.EstimatorSpec(
            mode=mode,
            predictions={
                'class': predicted_classes,
                'prob': tf.nn.softmax(logits)
            })
 
      # 生成一个 one-hot 编码的 label
    onehot_labels = tf.one_hot(labels, MAX_LABEL, 1, 0)
     # loss 函数 交叉熵 
    loss = tf.losses.softmax_cross_entropy(
        onehot_labels=onehot_labels, logits=logits)
    # train 模式下使用
    if mode == tf.estimator.ModeKeys.TRAIN:
        # 设置 学习率为0.1的 AdamOptimizer
        optimizer = tf.train.AdamOptimizer(learning_rate=0.01)
        # minimize loss function
        train_op = optimizer.minimize(loss, global_step=tf.train.get_global_step())
        return tf.estimator.EstimatorSpec(mode, loss=loss, train_op=train_op)
    
    # Score 时候使用
    eval_metric_ops = {
        'accuracy': tf.metrics.accuracy(
            labels=labels, predictions=predicted_classes)
    }
    return tf.estimator.EstimatorSpec(
        mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)