textcnn文本词向量_心法利器[4] | tf.keras文本分类小例子

最新推荐文章于 2023-11-17 10:10:14 发布

通冠农场多彩三角梅

最新推荐文章于 2023-11-17 10:10:14 发布

阅读量110

点赞数

文章标签： textcnn文本词向量

本文链接：https://blog.csdn.net/weixin_42494628/article/details/112503079

版权

【前沿重器】

全新栏目，本栏目主要和大家一起讨论近期自己学习的心得和体会，与大家一起成长。具体介绍：仓颉专项：飞机大炮我都会，利器心法我还有。

往期回顾

前沿重器[1] | 微软小冰-多轮和情感机器人的先行者
前沿重器[2] | 美团搜索理解和召回
前沿重器[3] | 平安智能问答系统
心法利器[1] | NLP知识蒸馏思考
心法利器[2] | 统计语言模型使用反思
心法利器[3] | tf.keras自学笔记

前几天学了tf.keras，趁热打铁我就整了一个自己比较熟悉的文本分类任务来试试手，效果可能不是很重要，重要的是能把流程走通，所以一切从简。

当然，我这里不想只是简单的弄个流程，码面条那么简单，我还是希望能整一次完整的工程化的代码来练练手，2天时间，纯手打欢迎各位前辈拍砖，也希望对各位有所帮助吧。

懒人目录：

文件结构和模块划分思路
预训练
分类模型
MAIN
- 预处理部分
- word2vector
- 建模操作
小结
- 后续改进计划
- 思路小结

文件结构和模块划分思路

先聊聊整套方案的算法视角思路，文本分类任务的常规基线是TextCNN，这里为了简单我只用了一个简单的卷积层，而没有用TextCNN里面那种复杂形式(有关这个模型的具体解释详见：NLP.TM[24] | TextCNN的个人理解)。

先来看核心代码的文件夹结构：

cls，文本分类模型，以及具体的任务实验。
ptm，预训练模型。
util，工具。

这里面的base_pipline.py是一套完整的流程化代码，接近180行，覆盖加载数据、预处理、训练、测试等全流程，当然我不满足于此，我把里面的关键步骤模块化，形成一个个分别的模块来分别实现。

预训练

预训练我单独拉出来，没有和整体模型放一起，主要是因为预训练模型需要单独训练，也完整地维护了起来，这里我只写了个最简单的word2vector，模型部分使用的也只是调了gensim的包，来看看完整的类代码。

import numpy as np
from nlu_model.util.pkl_impl import save_pkl, load_pkl
from gensim.models.word2vec import Word2Vec

class Word2vector(object):
    def __init__(self):
        self.word2idx_dic = {}
        self.embedding_weights = []

    def train(self, 
              train_data,                          # 训练数据
              N_DIM = 300,                         # word2vec的数量
              MIN_COUNT = 5,                       # 保证出现的词数足够做才进入词典
              w2v_EPOCH = 15,                      # w2v的训练迭代次数
              MAXLEN = 50                          # 句子最大长度
              ):

        self.N_DIM = N_DIM
        self.MIN_COUNT = MIN_COUNT
        self.w2v_EPOCH = w2v_EPOCH
        self.MAXLEN = MAXLEN

        # Initialize model and build vocab
        imdb_w2v = Word2Vec(size=N_DIM, min_count=MIN_COUNT)
        imdb_w2v.build_vocab(train_data)

        # Train the model over train_reviews (this may take several minutes)
        imdb_w2v.train(train_data, total_examples=len(train_data), epochs=w2v_EPOCH)

        # word2vec后处理
        n_symbols = len(imdb_w2v.wv.vocab.keys()) + 2
        embedding_weights = [[0 for i in range(N_DIM)] for i in range(n_symbols)]
        np.zeros((n_symbols, 300))
        idx = 1
        word2idx_dic = {}
        w2v_model_metric = []
        for w in imdb_w2v.wv.vocab.keys():
            embedding_weights[idx] = imdb_w2v[w]
            word2idx_dic[w] = idx
            idx = idx + 1

        # 留给未登录词的位置
        avg_weights = [0 for i in range(N_DIM)]
        for wd in word2idx_dic:
            avg_weights = [(avg_weights[idx]+embedding_weights[word2idx_dic[wd]][idx]) for idx in range(N_DIM)]
        avg_weights = [avg_weights[idx] / len(word2idx_dic) for idx in range(N_DIM)]
        embedding_weights[idx] = avg_weights
        word2idx_dic[""] = idx

        # 留给pad的位置
        word2idx_dic[""] = 0

        self.word2idx_dic = word2idx_dic
        self.embedding_weights = embedding_weights

    def save(self,
             word2idx_dic_path,                   # 词到ID词典路径
             embedding_path,                      # embedding词向量路径
             model_conf_path                     # 模型配置加载)
             ):
      
        # 保存w2id词典
        save_pkl(word2idx_dic_path, self.word2idx_dic)
        # 保存词向量矩阵
        save_pkl(embedding_path, self.embedding_weights)
        # 保存配置
        save_pkl(model_conf_path, [self.N_DIM, self.MIN_COUNT, self.w2v_EPOCH, self.MAXLEN])

    def __load_default__(self):
        self.load("./data/ptm/shopping_reviews/w2v_word2idx2020100601.pkl",
                  "./data/ptm/shopping_reviews/w2v_model_metric_2020100601.pkl", 
                  "./data/ptm/shopping_reviews/w2v_model_conf_2020100601.pkl")

    def load(self, word2idx_dic_path, embedding_path, model_conf_path):
        self.N_DIM, self.MIN_COUNT, self.w2v_EPOCH, self.MAXLEN = load_pkl(model_conf_path)
        self.embedding_weights = load_pkl(embedding_path)
        self.word2idx_dic = load_pkl(word2idx_dic_path)


    def word2idx(self, word):
        if len(self.word2idx_dic) == 0:
            self.__load_default__()
        if word in self.word2idx_dic:
            return self.word2idx_dic[word]
        else:
            return len(self.word2idx_dic) - 1

    def sentence2idx(self, sentence):
        sentence_idx = []
        for idx in range(len(sentence)):
            sentence_idx.append(self.word2idx(sentence[idx]))
        return sentence_idx

    def batch2idx(self, source_data):
        result_data = []
        for idx in range(len(source_data)):
            result_data.append(self.sentence2idx(source_data[idx]))
        return result_data

    def get_np_weights(self):
        return np.array(self.embedding_weights)

这里占比最大的是模型训练过程中的数据处理，剩下都是围绕着这个训练完的word2vector做的一些操作，我来画几个重点吧：

词汇的id化。tensorflow在训练过程中embedding_lookup本身是数字计算，所以所有的词汇都要转化为id，而这个id的生成其实来源于word2vector的训练，因此我把映射词典也放在这个类里面维护了，那就包括了各种粒度的映射了。
模型和映射词典以及一些必要的参数保存，我用的是pkl来进行保存，这个保存和加载都比较简单，来看具体的pkl_impl我是怎么写的：

import pickle

def save_pkl(path, data):
 output = open(path, 'wb')
 pickle.dump(data, output)
 output.close()

def load_pkl(path):
 pkl_file = open(path, 'rb')
 data = pickle.load(pkl_file)
 pkl_file.close()
 return data

在词典部分，我手动加了两个特殊词条：未登录词，对应的词向量是所有词向量的均值，pad补全，对应词向量全都是0。

当然，后续还可能有更多预训练的模型，自己可以再调整，这也是模块化的好处，后续要更新模型，就和换零件一样。

分类模型

分类模型这块是分了两层，一个cls模型类，一个具体的模型也把他整成一个类了(这个后续会整一个抽象类让他继承吧)。

首先看具体模型的类，textcnn_small，毕竟这个不是正儿八经的那个textcnn。

from tensorflow import keras

class TextCNNSmall():
    """docstring for TextCNNSmall"""
    def __init__(self, model_conf, train_conf={"batch_size":64,"epochs":3, "verbose":1}):
        self.model_conf = model_conf
        self.train_conf = train_conf
        self.__build_structure__()


    def __build_structure__(self):
        inputs = keras.layers.Input(shape=(self.model_conf["MAX_LEN"],))
        embedding_layer = keras.layers.Embedding(output_dim = self.model_conf["w2c_len"],
                                    input_dim = len(self.model_conf["emb_model"].embedding_weights), 
                                    weights=[self.model_conf["emb_model"].get_np_weights()], 
                                    input_length=self.model_conf["MAX_LEN"], 
                                    trainable=True
                                    )
        x = embedding_layer(inputs)

        l_conv1 = keras.layers.Conv1D(filters=self.model_conf["w2c_len"], kernel_size=3, activation='relu')(x)  
        l_pool1 = keras.layers.MaxPool1D(pool_size=3)(l_conv1)
        l_pool11 = keras.layers.Flatten()(l_pool1)

        out = keras.layers.Dropout(0.5)(l_pool11)
        output = keras.layers.Dense(32, activation='relu')(out)
         
        pred = keras.layers.Dense(units=1, activation='sigmoid')(output)
         
        self.model = keras.models.Model(inputs=inputs, outputs=pred)
        self.model.summary()
        self.model.compile(loss="binary_crossentropy", optimizer="adam", metrics=['accuracy'])

    def fit(self, x_train, y_train, x_test, y_test):
        history = self.model.fit(x_train, y_train, batch_size=self.train_conf.get("batch_size", 64),
                                epochs=self.train_conf.get("epochs", 3),
                                validation_data=(x_test, y_test),
                                verbose=self.train_conf.get("verbose", 1))
        return history

    def evaluate(self, x_test, y_test):
        return self.model.evaluate(x_test, y_test)

    def predict(self, sentences):
        return self.model.predict(sentences)

    def save(self, path):
        if self.model:
            self.model.save(path)

    def load(self, path):
        self.model = keras.load_model(path)

就科研而言模型还是核心，但实际上我还做了很多模型法之外的事情：

简单的模型构建，这块没什么难的了。
fit、evaluate、predict，这是经典的3个模型关键步骤，训练、评估、预测，对于工程而言，最关键的应该就是预测了。
模型的加载和保存，这块我也涉及到了。
这里面的参数我都配置化了，从外面输入进来，当然这种字典的形式只是个权宜之计，后续我会汇总好形成各种接口来往外直接暴露。

模型类之上我还整了一个模型类，用来对各种同类型的模型进行维护。

import jieba
from tensorflow import keras
from nlu_model.cls.model.textcnn_small import TextCNNSmall

class ClsModel(object):
    def __init__(self, model_choice, model_conf={}, train_conf={}):
        self.model_choice = model_choice
        self.model_conf = model_conf
        self.train_conf = train_conf
        self.__model_select__()

    def __model_select__(self):
        if self.model_choice == "textcnn_small":
            self.model = TextCNNSmall(self.model_conf, self.train_conf)
        if self.model_choice == "load":
            self.load(self.model_conf["path"])

    def preprocess(self, sentences):
        sentences = [list(jieba.cut(i)) for i in sentences]
        sentence_id = self.model_conf["emb_model"].batch2idx(sentences)
        return keras.preprocessing.sequence.pad_sequences(sentence_id,
                                                          value=0,
                                                          padding='post',
                                                          maxlen=50)

    def fit(self, x_train, y_train, x_test, y_test):
        return self.model.fit(x_train, y_train, x_test, y_test)

    def evaluate(self, x_test, y_test):
        return self.model.evaluate(x_test, y_test)

    def pred(self, sentence):
        return self.model.predict(sentence)

    def predict(self, sentences):
        sentence_id = self.preprocess(sentences)
        return self.pred([sentence_id])[0][0]

    def save(self, path):
        self.model.save(path)

    def load(self, path):
        self.model = keras.models.load_model(path)

同样画画重点。

这里的模型首先由__model_select__来进行统一维护和选择，目前支持两种模式，textcnn_small即一个具体的模型，另外的load是加载模式，维护具体的一个模型。
__用来区分是private类型成员还是public类型成员，即外界是否能读到，一般不需要外界读的尽量整成__，这里我还需要优化。
预处理的这块工作具有一定的重用性，但是仅在文本分类中使用，因此我也维护在这里了，后续可以尝试看看能不能放在util里面。
训练、评估、预测3连，但是这里我整了两个预测，一个是直接针对预处理好的id化序列进行预测，另一个是针对原句来进行预测，其实可以看到后者调用了前者的那个函数。

MAIN

有了这些模块，我们就需要把他们给串起来了，这里我用的是网上找的一套电商评论好坏评的分类数据(https://blog.csdn.net/churximi/article/details/61210129)

预处理部分

首先是预处理部分：

# data preprocess
def loadfile():
    # 加载并预处理模型
    neg = pd.read_excel('./data/cls/shopping_reviews/neg.xls', header=None, index=None)
    pos = pd.read_excel('./data/cls/shopping_reviews/pos.xls', header=None, index=None)

    def cw(x): 
        punctuation = r"[\s+\.\!\/_,$%^*(+\"\']+|[+——！，。？、~@#￥%……&*()：]+"
        x = re.sub(punctuation, "", x)

        return list(jieba.cut(x))
    pos['words'] = pos[0].apply(cw)
    neg['words'] = neg[0].apply(cw)

    y = np.concatenate((np.ones(len(pos)), np.zeros(len(neg))))

    x_train, x_test, y_train, y_test = train_test_split(
        np.concatenate((pos['words'], neg['words'])), y, test_size=0.2)
    
    return x_train, x_test, y_train, y_test

x_train, x_test, y_train, y_test = loadfile()
with open("./data/cls/shopping_reviews/train.txt", "w") as f:
    for idx in range(len(x_train)):
        f.write("%s\t%s\n" % (y_train[idx], " ".join(x_train[idx])))

with open("./data/cls/shopping_reviews/test.txt", "w") as f:
    for idx in range(len(x_test)):
        f.write("%s\t%s\n" % (y_test[idx], " ".join(x_test[idx])))

源文件在excel里面，我去了标点后切词，切完之后做了数据划分，然后分别保存起来了。

word2vector

word2vector = Word2vector()

word2vector.train(x_train)
word2vector.save("./data/ptm/shopping_reviews/w2v_word2idx2020100601.pkl",
                 "./data/ptm/shopping_reviews/w2v_model_metric_2020100601.pkl", 
                 "./data/ptm/shopping_reviews/w2v_model_conf_2020100601.pkl")

然后是Word2vector的训练，可以看到这块代码非常简洁方便，后续自己再用的时候就很舒服，所以我本身非常喜欢去包装这些东西。

建模操作

建模这块，主要有这几个细节步骤：

训练测试数据的结构转化，要使其符合模型需要的类型。
模型建立和初始化。
训练、评估。
单独测试case。

然后来看看代码：

# 训练测试数据的结构转化，要使其符合模型需要的类型。
x_train = word2vector.batch2idx(x_train)
x_test = word2vector.batch2idx(x_test)

x_train = keras.preprocessing.sequence.pad_sequences(x_train,
                                                    value=0,
                                                    padding='post',
                                                    maxlen=50)
x_test = keras.preprocessing.sequence.pad_sequences(x_test,
                                                    value=0,
                                                    padding='post',
                                                    maxlen=50)

# 模型建立和初始化
model_conf = {"MAX_LEN": 50,
              "w2c_len": 300, 
              "emb_model": word2vector}
train_conf = {"batch_size": 64,
              "epochs": 5, 
              "verbose": 1}
cls_model = ClsModel("textcnn_small", model_conf, train_conf)

# 训练、评估
cls_model.fit(x_train, y_train, x_test, y_test)
print(cls_model.evaluate(x_test, y_test))
cls_model.save("./data/cls/shopping_reviews/model_20201007")

# 单独测试case，这里包括用新训练好的模型和保存加载后的模型
sentence = "这台手机真性能还挺好的"
print(cls_model.predict([sentence]))

sentence = "这台手机真性能还挺好的"
word2vector = Word2vector()
cls_model = ClsModel("load", model_conf={"path":"./data/cls/shopping_reviews/model_20201007", "emb_model": word2vector}, train_conf={})
print(cls_model.predict([sentence]))

小结

后续改进计划

这只是初步建立的一个架构，细节还不太完整，需要完善。

注释太少。(为了在今晚发问，所以省了些大家不会介意吧)
在一个超大的项目下，其实还缺少打包、部署之类的框架类脚本和模块，例如用flask等。
同样是大项目下，有多个模型和词典时，需要一个model_manager之类的来维护，有兴趣的可以去看看jieba的源码。
没有日志、没有耗时计算工具。
针对单字的操作可以做。

时候未到，尚未开源，敬请期待。

思路小结

会做实验写算法是一方面，会把自己的东西规范化、结构化整上线又是另一回事，真正的算法工程师，要足够全面，了解工程，最终才能够完成这个项目，有了这个框架，自己尝试更多的模型其实会更加快哈哈哈。

通冠农场多彩三角梅

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
textcnn文本词向量_心法利器[4] | tf.keras文本分类小例子

【前沿重器】全新栏目，本栏目主要和大家一起讨论近期自己学习的心得和体会，与大家一起成长。具体介绍：仓颉专项：飞机大炮我都会，利器心法我还有。往期回顾前沿重器[1] | 微软小冰-多轮和情感机器人的先行者前沿重器[2] | 美团搜索理解和召回前沿重器[3] | 平安智能问答系统心法利器[1] | NLP知识蒸馏思考心法利器[2] | 统计语言模型使用反思心法利器[3] | tf.keras...
复制链接

扫一扫