Observaciones sobre PNL china: 11. ¿En base a qué? ¿LSTM? Generar poesía antigua
1? ¿Preparación del corpus
? Hay más de 40.000 poemas antiguos, un verso a la vez.
Paso 2: ¿Preprocesamiento
? Representa el carácter chino como 一热.
? Agregar el símbolo ] al final de cada línea indica que el poema ha terminado, lo que indica que la oración anterior al símbolo ] no está relacionada con la oración posterior, y los datos de entrenamiento que contienen el símbolo ] se descartarán más adelante.
? Pun = [']', '[', '(', ')', ' { ', ' } ', ':', '《》']
Definir archivo de preprocesamiento (configuración):
Contenido de texto #Corpus
files_content = ' '
Usar open(config. poema_file, 'r', encoding='utf-8 ') como f :
Para las líneas en f:
#Agregue el símbolo "]" al final de cada línea para indicar el final de un poema.
Para char en juegos de palabras:
line = line.replace(char, "")
files_content += line.strip() + "]"
palabras = ordenado(lista(archivos _ contenido))
palabras.remove(']')
palabras_contadas = {}
Palabra por palabra:
Si el recuento de palabras es counting_word count:
palabras_contadas[palabra] += 1
En caso contrario:
palabras_contadas[ palabra ] = 1
#Eliminar palabras de baja frecuencia
erase = []
Para contar claves en palabras:
Si se cuentan_ palabras[clave]<= 2:
erase.append(clave)
Para borrar clave:
del counted_words[clave]
del palabras_contadas[']']
pares de palabras = ordenados(palabras _ contadas . elementos(), clave=lambda x: -x[1])
Palabras , _ = zip(*par de palabras)
#Asignación de palabra a ID
word2num = dict((c, i + 1) for i, c in enumerate(words))
num2palabra = dict((i, c) for i, c in enumerate(words))
palabra 2 numf = lambda x:palabra 2 num get(x, 0)
Devuelve word2numF, num2word, palabras, files_content
3. ¿Configuración de parámetros del modelo
? Configuración de clase (objeto):
poema_archivo='poema txt'
peso_archivo='poema_modelo'
#Según. las seis palabras anteriores predicen la séptima palabra
max_len = 6
batch_size = 512
learning_rate = 0.001
4.
? ¿Implementado por la clase PoetryModel
? clase PoetryModel(objeto):
def __init__(self, config):
pasar
definir build_model (self):
Pasar
def muestra(self, predicción, temperatura=1.0):
Aprobado
def generate_sample_result(self, period, log):
pasar
definir predicción(self, texto):
pasar
definir data_generator(self):
pasar
Definir tren(self):
Pase
? (1) ¿Función de inicialización
? Cargar información de configuración, preprocesar corpus y cargar modelo.
? def __init__(self, config):
self.model = Ninguno
self.do_train = True
self.loaded_model = False
self.config = configuración
#Preprocesamiento de archivos
self.word2numF, self.num2word, self.words, self.files_content = preprocess_file(self. config)
Si la ruta del sistema operativo existe (self . config . peso _ archivo):
self . model.summary()
De lo contrario:
self.train()
self.do_train = False
self.loaded_model = True
? (2) ¿Establecer la función del modelo
? ¿Establecimiento del modelo GRU
? Definir build_model(self):
''Crear modelo'''
Entrada _ tensor = Entrada(forma = (self . config . max _ len,))
embedd = Incrustación(len(self . num 2 palabra)+1, 300, input_length = self . config . max _ len)(input _ tensor)
lstm = bidireccional( GRU(128, return_sequences=True))(incrustado)
Abandono = abandono(0.6)(lstm)
lstm = bidireccional(GRU(128, return_sequences=True))(incrustado)
Abandono = abandono(0.6)(lstm)
aplanar = Aplanar()(lstm)
denso = Denso(len(self.words), activación='softmax ')(aplanar)
self.model = Modelo(entrada=tensor de entrada, salida=denso)
optimizador = Adam(lr = self . config . learning _ rate)
modelo propio. Compilación (pérdida = 'categoría _ entropía cruzada', optimizador = optimizador, métricas = ['precisión'])
? (3)Función de muestra
? def muestra(self, predicción, temperatura=1.0):
preds = np.asarray(preds).
astype('float64 ')
preds = np.log(preds) /temperatura
exp_preds = np.exp(preds)
preds = exp _ preds /NP . suma(exp _ preds)
probas = NP multinomial(1, preds, 1)
Devuelve np.argmax(probas)
? (4) ¿Modo de entrenamiento
? def generate_sample_result(self, epoch, log):?
Imprimir(" \n = = = = = = = = = = = = = = = = Era {}=================== = ==".format(epoch))
Para diversidad en [0.5, 1.0, 1.5]:
Imprimir("-diversity{}-"). formato (diversidad))
start_index = random.randint(0, len(self. files_content)-self.config.max_len-1)
generated= ' '
frase = self . files _ content[start _ index:start _ index+self config .
Generar += frase
Para I(20) en rango:
x_pred = np.zeros((1, self.config.max_len))
Para t, char en enumerate(oración [- 6:]):
x_pred[0, t] = self.word2numF(char)
preds = self.pred(x_pred, verbose=0)[0]
next_index. = self.sample(predicción, diversidad)
next _ char = self num 2 palabra[next _ index]
generado += next_char
Oración =. oración + siguiente carácter
Imprimir (oración)
? (5) ¿Función de predicción
? Generar poesía basada en las palabras dadas.
? define predicción(self, text):
Si no es selfload_model:
Regresar
Usa open(self . config . poema_file, 'r ', encoding=' utf-8 ') as f:
file_list = f.readlines()
líneas aleatorias = seleccionadas aleatoriamente (lista de archivos)
#Si el texto dado tiene menos de cuatro caracteres, complételo al azar.
¡Si no es texto o len(texto)! = 4:
for _ in range(4 - len(text)):
random _ str _ index = random .
text+= self . num 2 palabra . get(random _ str _ index)si self . num 2 palabra get(random _ str _ index) no está en [', ', ' .,
? ,'] else self.num2word.get(
random_str_index + 1)
seed = random _ line[-(self . config . max _ len):-1]
res = ' '
Semilla = 'c' + semilla
Para c en texto:
semilla = semilla[1:] + c
Para j en el rango (5):
x_pred = np.zeros((1, self.config.max_len))
Para t, caracteres (semillas) en la enumeración:
x_pred[0, t] = self.word2numF(char)
preds = self. predict(x_pred, verbose =0)[0. ]
next_index = self.sample(preds, 1.0)
next _ char = self num 2 palabra[next _ index]
seed = semilla[. 1:] + next_char
Semilla
Recurso devuelto
? (6) ¿Función de generador de datos
? Generar datos para el entrenamiento de modelos.
definir data_generator(self):
i = 0
y 1:
x = self archivos _ contenido [I: I+self .config .max _ len]
y = self .files _ content[I+self config . [', '(', ')', ' { ', ' } ', ':', '《》, ':']
if len([juego de palabras en I para I si en incógnita])! = 0:
i += 1
Continuar
if len([I para I si I en y])! = 0:
i += 1
Continuar
y_vec = np.zeros(
forma=(1,len(self .words)),
dtype=np.bool
)
y_vec[0, self.word2numF(y)] = 1.0
x_vec = np.zeros(
shape=(1, self.config.max_len),
dtype=np.int32
)
Para t, char en enumerate(x):
x_vec[0, t] = self.word2numF(char)
Rendimiento x_vec, y_vec
i += 1
? (7) ¿Función de entrenamiento
? Definir tren (self):
# número _ de _ época = len(self . files _ content)//self config lote _ tamaño
Número de época = 10
Si no es tu propio modelo:
self.build_model()
self.model.summary()
self.model. fit_generator(
generator=self.data_generator(),
verbose=True,
steps_per_epoch = self.config.batch_size,
Número de épocas = número de épocas,
Callback=[
keras . punto de control del modelo (self . config . Weight_file, save_weights_only=False),
devolución de llamada lambda(on _ epoch _ end = self . generate _ sample _ result)
]
)
5.Continuar con el entrenamiento del modelo.
? modelo = PoetryModel(configuración)
Escribir poesía
? texto = input("text:")
frase = model.predict(texto)
Imprimir (frase)
Materiales de estudio:
Introducción al procesamiento práctico del lenguaje natural chino