Fale sobre a aplicação do modelo de linguagem novamente

Forma de modelo de linguagem

O modelo de linguagem apresentado acima obteve resultados muito bons, mas é lento no ambiente de produção. Portanto, o objetivo deste artigo é experimentar um modelo de linguagem mais leve. O segundo é a tarefa de downstream do modelo de linguagem. a aplicação, o modelo da linguagem é essencialmente para descobrir as associações potenciais na gramática da linguagem.A aplicação deste método em teoria será muito útil na tarefa de julgar a semântica do texto.

Aplicação modelo VAE

Aqui é mostrado que VAE é adicionado ao processo de geração de texto. Lm_loss é usado para auxiliar na geração de texto. Algumas coisas sobre VAE não serão expandidas aqui. Tenho tempo para atualizá-lo separadamente.

O código da parte da perda : (lm_loss é uma nova perda adicionada na base original)

xent_loss = K.sum(K.sparse_categorical_crossentropy(input_sentence, output), 1)
kl_loss = - 0.5 * K.sum(1 + z_log_var - K.square(z_mean) - K.exp(z_log_var), axis=-1)

lm_loss_layer = LM_loss_layer(word_dic, inpit_pad,name="loss_lm")
lm_loss_layer.trainable = False
lm_loss = lm_loss_layer(output)

vae_loss = K.mean(xent_loss + kl_loss + lm_loss)

O código-chave da camada personalizada lm_loss

    def call(self, x, mask=None):
     
        data_shape = K.int_shape(x)
        pad_shape = K.int_shape(self.pad_data)
        word_len = data_shape[1]  # 词序列的长度
        pad_len = pad_shape[1]

        pad_data = K.cast(self.pad_data, tf.int64)
        pad_data_onehot = K.one_hot(indices=pad_data, num_classes=data_shape[-1])

        lm_input = K.concatenate((pad_data_onehot, x), axis=1)

        lm_out = self.lm_model(lm_input)
        class_num = K.int_shape(lm_out)[-1]

        lm_out = K.reshape(x=lm_out, shape=(-1, word_len + pad_len, class_num))

        lm_out = K.max(lm_out, axis=-1) 

        res = -K.log(lm_out)

        res = K.sum(res)

        return res

Os resultados do experimento são relativamente de demonstração: o
computador está morrendo de calor, então se você tiver a chance de postar um efeito, não será muito bom em teoria porque a base ainda é um modelo VAE.
Se você tem amigos experimentais, também pode adicionar peso à perda.
O pré-requisito efetivo é ter um bom LM, caso contrário, a perda diminuirá e será desconfortável.

Aplicação modelo NER

Há também uma pequena demonstração para aplicar o modelo de linguagem à tarefa de NER. Descobri que o efeito foi bom no teste anterior do bert, mas a velocidade de produção é relativamente lenta, então quero substituí-lo por um LM portátil, e o LM pode ser customizado de acordo com as necessidades Definir treinamento. Cole algum código aqui.

    def build_model(self):
        inpute_ = layers.Input((self.max_sentence_len,))
        #lm  embeding
        inpit_pad = layers.Input(shape=(self.ngram,))
        lm_embeding_layer = LM_embeding_layer()
        
        emb_lm = lm_embeding_layer([inpute_,inpit_pad])

        emb = layers.Embedding(input_dim=self.word_num, output_dim=128)(inpute_)  
        embedding_layer = layers.Concatenate(axis=-1)([emb, emb_lm])

        model1_in = layers.Conv1D(filters=self.CONV_SIZE, kernel_size=2, activation="relu", padding="same")(
            embedding_layer)
        model1_in = layers.MaxPooling1D(pool_size=2, strides=1, padding="same")(model1_in)

        model2_in = layers.Conv1D(self.CONV_SIZE, kernel_size=4, activation="relu", padding="same")(embedding_layer)
        model2_in = layers.MaxPooling1D(pool_size=2, strides=1, padding="same")(model2_in)

        model3_in = layers.Conv1D(self.CONV_SIZE, kernel_size=6, activation="relu", padding="same")(embedding_layer)
        model3_in = layers.AveragePooling1D(pool_size=2, strides=1, padding="same")(model3_in)

        merged = layers.concatenate([model1_in, model2_in, model3_in, embedding_layer], axis=-1)  # merge
        crf = CRF(self.class_num, sparse_target=False)
        crf_res = crf(merged)
        model = Model([inpute_, inpit_pad], crf_res)

        adam = Adam(lr=0.001)
        model.compile(optimizer=adam, loss=crf.loss_function, metrics=[crf.accuracy])
        print(model.summary())
        return model