Formulario de modelo de lenguaje
El modelo de lenguaje presentado anteriormente ha logrado muy buenos resultados, pero es lento en el entorno de producción. Por lo tanto, el propósito de este artículo es experimentar con un modelo de lenguaje más ligero. El segundo es la tarea posterior del modelo de lenguaje. La aplicación, el modelo del lenguaje, es esencialmente para descubrir las posibles asociaciones en la gramática del lenguaje La aplicación de este método en teoría será de gran ayuda en la tarea de juzgar la semántica del texto.
Aplicación del modelo VAE
Aquí se muestra que VAE se agrega en el proceso de generación de texto. Lm_loss se usa para ayudar a la generación de texto. Algunas cosas sobre VAE no se ampliarán aquí. Tengo tiempo para actualizarlo por separado.
El código de la parte de pérdida : (lm_loss es una nueva pérdida agregada sobre la 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)
El código clave de la capa 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
Los resultados del experimento son relativamente de demostración: la
computadora se está muriendo de calor, por lo que si tiene la oportunidad de publicar un efecto, en teoría no será demasiado bueno porque la base sigue siendo un modelo VAE.
Si tiene amigos experimentales, también puede agregar peso a la pérdida.
El prerrequisito efectivo es tener un buen LM, de lo contrario la pérdida disminuirá y será incómoda.
Aplicación del modelo NER
También hay una pequeña demostración para aplicar el modelo de lenguaje a la tarea de NER. Encontré que el efecto fue bueno en la prueba anterior de bert, pero la velocidad de producción es relativamente lenta, así que quiero reemplazarlo con un LM portátil, y el LM se puede personalizar según las necesidades Definir formación. Pega un código aquí.
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