【大模型实战篇】一种关于大模型高质量数据的处理方法-无标注数据类别快速识别及重复数据检测（加权向量-卷积神经网络-聚类算法结合）

1. 背景介绍  

        大模型的能力很大程度上依赖于高质量的数据，在之前的一篇文章《高质量数据过滤及一种BoostedBaggingFilter处理方法的介绍》中，我们介绍了大模型的数据处理链路，本文继续关注在高质量数据的模块。

        本文所要介绍的处理方法，其实是很多年之前在构建对话机器人系统中涉及的，当时的场景是需要对不同地区的用户大量问题进行自动化区分，识别出热门问题，并给出类别划分，进而给出不同类别问题的热门问答示例，展现在用户的对话框窗口，对于不同地区的问题都需要做类似处理。做过对话系统的同学应该有一种感受，那就是当用户问答数据够多时，其实问答系统的主要任务就变成了对于历史问题的匹配和检索，因此用户问题往往是相似的。

        之所以该方法同样可以适用大模型数据处理领域，是因为大模型的训练数据往往是从大量的网站或者其他数据源获取的，原始数据可能并没有完整的类别区分，并且可能涉及到重复数据，而人工标注又非常的耗时且昂贵。因此完全可以采用类似的针对热门问题自动识别的方式，对原始数据进行快速自动划分类别，识别重复数据等。

2. 具体算法介绍

        针对热门问题自动识别的方法，我们主要采用cnn+kmeans方式，结合了卷积神经网络（CNN）特征提取和 K均值聚类（K-Means）算法，用于文本数据的聚类识别，这种处理方式速度快、资源要求低，适合在大规模数据上进行处理。这个处理流程整合了词嵌入、卷积神经网络以及聚类算法，能够对文本数据进行有效的特征提取和聚类分析。其中对于加权平均词嵌入向量的处理可以注意下，这一步对于文本语意的表达比较重要。

算法流程及原理

1. 数据预处理：

   • 文本清洗和分词：去除噪声并分词。
   • 分词序列化：使用 Tokenizer 对文本进行编码，将文本转换为词索引的序列。
   • 词嵌入：加载预训练的词向量，并构建词嵌入矩阵，其中每个词都有对应的向量表示。
   • 序列填充：对词索引序列进行填充或截断，使得所有样本具有相同的长度。

2. 构建词嵌入矩阵：

   • 加载预训练的词向量模型。
   • 初始化嵌入矩阵，使用预训练的词向量填充矩阵。
   • 统计未命中词向量的词。

3. 构建平均词嵌入向量：

   • 使用 TF-IDF 对词频进行加权。
   • 归一化 TF-IDF 值，并计算加权平均词嵌入向量。
   • 将平均词嵌入向量二值化，即对每个样本的向量进行处理，保留那些超过中位数的特征。

4. 构建模型：

   • 输入层接受序列化的文本数据。
   • 嵌入层使用预训练的词向量。
   • 卷积层对嵌入后的序列进行卷积操作。
   • 全局最大池化层提取卷积特征。
   • 输出层使用 Sigmoid 激活函数，输出维度等于二值化后的向量维度。

5. 训练模型：

   • 使用二值化的向量作为监督信号训练模型。
   • 保存最佳权重，并从倒数第二层推断出中间表示。
   • 对中间表示进行 L2 归一化，并使用 K-Means 聚类算法进行聚类。

主要步骤

• 初始化：加载预训练词向量，初始化 tokenizer。
• 文本预处理：分词、构建词嵌入矩阵、计算平均词嵌入向量并二值化。
• 构建模型：定义 CNN 模型结构，编译模型。
• 训练模型：拟合模型，保存最佳权重。
• 推断：使用训练好的模型从倒数第二层获取中间表示。
• 聚类：对中间表示进行聚类，并将结果输出。

示例代码：

from utils.data_preprocess import DataTools
import numpy as np
from gensim.models.keyedvectors import KeyedVectors
from keras.callbacks import ModelCheckpoint
from keras.optimizers import Adam
from keras.preprocessing.text import Tokenizer
from keras.preprocessing.sequence import pad_sequences
from keras.layers import Input, Embedding
from keras.layers import Dense, Conv1D, Dropout
from keras.layers import GlobalMaxPooling1D
from keras.models import Model
from sklearn.cluster import KMeans
from sklearn.preprocessing import normalize

class CNNKMeans(object):
    def __init__(self):
        self.data_tools = DataTools()
        self.EMBEDDING_FILE = 'data/ss_vector300.bin' #加载预训练的词向量数据
        self.tokenizer = Tokenizer()
        self.EMBEDDING_DIM = 300

    def cluster_texts(self, texts, clusters=50, n_iters=10):
        self.text_preprocess(texts)
        model = self.get_model()
        H = self.train_model_and_infer(model, n_iters)
        #使用倒数第二层的输出作为infer的向量进行聚类
        km = KMeans(n_clusters=clusters, n_jobs=2)
        V = normalize(H, norm='l2')
        km.fit(V)
        pred_y = km.labels_
        return pred_y

    # 文本预处理&构建格式化输入输出数据
    def text_preprocess(self, texts):

        '''
        （1）分词并向量化
        '''

        texts = [" ".join(self.data_tools.process_text(text)) for text in texts]
        self.tokenizer.fit_on_texts(texts)
        #texts_to_sequences可获得 [词的index列表]
        sequences_full = self.tokenizer.texts_to_sequences(texts)
        word_index = self.tokenizer.word_index
        print('Found %s unique tokens.' % len(word_index))
        MAX_NB_WORDS = len(word_index)
        seq_lens = [len(s) for s in sequences_full]
        print("Average length: %d" % np.mean(seq_lens))
        print("Max length: %d" % max(seq_lens))
        self.MAX_SEQUENCE_LENGTH = max(seq_lens)
        self.X = pad_sequences(sequences_full, maxlen=self.MAX_SEQUENCE_LENGTH)

        '''
        （2）构建词嵌入矩阵
        '''
        word2vec = KeyedVectors.load_word2vec_format(self.EMBEDDING_FILE, binary=True)
        self.nb_words = min(MAX_NB_WORDS, len(word_index)) + 1
        self.embedding_matrix = np.zeros((self.nb_words, self.EMBEDDING_DIM))
        for word, i in word_index.items():
            if word in word2vec.vocab:
                self.embedding_matrix[i] = word2vec.word_vec(word)
            else:
                print(word)
        print('Null word embeddings: %d' % np.sum(np.sum(self.embedding_matrix, axis=1) == 0))

        '''
        （3）通过 Average embeddings (AE)构建目标映射向量, binary Y
        '''

        Y = {}
        #sequences_to_matrix 获得每一句话在全量词列表中对应出现词的tf-idf向量，如[[0,0,0, 0.3, 0, 1, 0, 0.5],[...]]
        tfidf = self.tokenizer.sequences_to_matrix(sequences_full, mode='tfidf')
        denom = 1 + np.sum(tfidf, axis=1)[:, None] #按行求和
        #对每一行进行归一化
        normed_tfidf = tfidf / denom
        #假如normed_tfidf.shape 为N X 1000, embedding_matrix shape  为 1000 X 300, 那么average_embeddings 的shape为 N X 300, 这一步可以理解为使用tf-idf的词重要性对每一句中的词向量做了加权求和，得到每一句文本的新的表征向量，之所以这么做，是考虑结合全局词重要性信息+局部的词语义信息。
        average_embeddings = np.dot(normed_tfidf, self.embedding_matrix)
        Y["ae"] = average_embeddings
        print("Shape of average embedding: ", Y['ae'].shape)
        reduction_name = "ae"
        self.B = self.binarize(Y[reduction_name])
        self.TARGET_DIM = self.B.shape[1]

    # 构建模型计算图
    def get_model(self):
        embedding_matrix_copy = self.embedding_matrix.copy()
        trainable_embedding = False
        # Embedding layer
        pretrained_embedding_layer = Embedding(
            input_dim=self.nb_words,
            output_dim=self.EMBEDDING_DIM,
            weights=[self.embedding_matrix],
            input_length=self.MAX_SEQUENCE_LENGTH,
        )

        # Input
        sequence_input = Input(shape=(self.MAX_SEQUENCE_LENGTH,), dtype='int32')
        embedded_sequences = pretrained_embedding_layer(sequence_input)

        # 1st Layer
        x = Conv1D(100, 5, activation='tanh', padding='same')(embedded_sequences)
        x = GlobalMaxPooling1D()(x)

        # Output
        x = Dropout(0.5)(x)
        predictions = Dense(self.TARGET_DIM, activation='sigmoid')(x)
        model = Model(sequence_input, predictions)

        model.layers[1].trainable = trainable_embedding

        adam = Adam(lr=1e-3, beta_1=0.9, beta_2=0.999, epsilon=1e-08)
        # Loss and Optimizer
        model.compile(loss='binary_crossentropy',
                      optimizer=adam,
                      metrics=['mae'])
        # Fine-tune embeddings or not
        model.summary()
        return model

    # 原始数据表征学习
    def train_model_and_infer(self, model, nb_epoch):
        checkpoint = ModelCheckpoint('models/weights.{epoch:03d}-{val_acc:.4f}.hdf5', monitor='val_acc', verbose=1,
                                     save_best_only=True, mode='auto')
        model.fit(self.X, self.B, validation_split=0.2,
                  epochs=nb_epoch, batch_size=100, verbose=1, shuffle=True)
        input = model.layers[0].input
        output = model.layers[-2].output
        model_penultimate = Model(input, output)
        # inference of penultimate layer
        H = model_penultimate.predict(self.X)
        print("Sample shape: {}".format(H.shape))
        return H

    # 二值化向量
    #只保留向量中超过中位数的特征值，置为1，其他置为0。也就是仅保留最重要的信息。
    def binarize(self, target):
        median = np.median(target, axis=1)[:, None]
        binary = np.zeros(shape=np.shape(target))
        binary[target > median] = 1
        return binary

if __name__ == "__main__":
    query_path = "data/query.txt"
    citywise=True
    K = 20
    nb_epoch = 50
    city = "北京"
    dir = "/cluster_result/"+city+"/cnnkmeans/"
    CKM = CNNKMeans()
    city_query_tokens = CKM.data_tools.data_taxonomy(query_path)
    if city in city_query_tokens:
        texts = city_query_tokens[city]
        clusters = CKM.cluster_texts(texts, K, nb_epoch)
        CKM.data_tools.cluster2csv(dir, clusters, texts, K, "CKM")

原文地址：https://blog.csdn.net/weixin_65514978/article/details/142426704

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！