Kaedah dan teknik untuk menghasilkan teks berterusan menggunakan LSTM

LSTM ialah varian rangkaian saraf berulang yang digunakan untuk menyelesaikan masalah pergantungan jangka panjang. Idea teras adalah untuk mengawal aliran input, output dan keadaan dalaman melalui satu siri unit berpagar, dengan itu berkesan mengelakkan masalah kecerunan yang hilang atau meletup dalam RNN. Mekanisme gating ini membolehkan LSTM mengingati maklumat untuk masa yang lama dan secara selektif melupakan atau mengemas kini keadaan mengikut keperluan, dengan itu memproses data jujukan panjang dengan lebih baik.

Prinsip kerja LSTM adalah untuk mengawal aliran dan pemeliharaan maklumat melalui tiga unit kawalan get, yang merangkumi get lupa, get input dan gate output.

Forgetting Gate: Mengawal sama ada keadaan sebelumnya perlu dilupakan, membenarkan model menyimpan maklumat keadaan sebelumnya secara selektif.

Ger masuk: Mengawal perkadaran maklumat input baharu dalam keadaan semasa, membenarkan model menambah maklumat baharu secara selektif.

Pintu keluaran: Mengawal output maklumat keadaan semasa, membenarkan model mengeluarkan maklumat keadaan secara selektif.

Sebagai contoh, katakan kita ingin menggunakan LSTM untuk menjana sekeping teks tentang cuaca. Pertama, kita perlu menukar teks kepada nombor, yang boleh kita lakukan dengan memetakan setiap perkataan kepada integer yang unik. Kami kemudiannya boleh memasukkan integer ini ke dalam LSTM dan melatih model untuk meramalkan taburan kebarangkalian perkataan seterusnya. Akhir sekali, kita boleh menggunakan taburan kebarangkalian ini untuk menjana teks berterusan.

Berikut ialah contoh kod untuk melaksanakan LSTM bagi menjana teks:

import numpy as np
import sys
import io
from keras.models import Sequential
from keras.layers import Dense, LSTM, Dropout
from keras.callbacks import ModelCheckpoint
from keras.utils import np_utils

# 读取文本文件并将其转换为整数
with io.open('text.txt', encoding='utf-8') as f:
    text = f.read()
chars =list(set(text))
char_to_int = dict((c, i) for i, c in enumerate(chars))

# 将文本分割成固定长度的序列
seq_length = 100
dataX = []
dataY = []
for i in range(0, len(text) - seq_length, 1):
    seq_in = text[i:i + seq_length]
    seq_out = text[i + seq_length]
    dataX.append([char_to_int[char] for char in seq_in])
    dataY.append(char_to_int[seq_out])
n_patterns = len(dataX)

# 将数据转换为适合LSTM的格式
X = np.reshape(dataX, (n_patterns, seq_length, 1))
X = X / float(len(chars))
y = np_utils.to_categorical(dataY)

# 定义LSTM模型
model = Sequential()
model.add(LSTM(256, input_shape=(X.shape[1], X.shape[2]), return_sequences=True))
model.add(Dropout(0.2))
model.add(LSTM(256))
model.add(Dropout(0.2))
model.add(Dense(y.shape[1], activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adam')

# 训练模型
filepath="weights-improvement-{epoch:02d}-{loss:.4f}.hdf5"
checkpoint = ModelCheckpoint(filepath, monitor='loss', verbose=1, save_best_only=True, mode='min')
callbacks_list = [checkpoint]
model.fit(X, y, epochs=20, batch_size=128, callbacks=callbacks_list)

# 使用模型生成文本
int_to_char = dict((i, c) for i, c in enumerate(chars))
start = np.random.randint(0, len(dataX)-1)
pattern = dataX[start]
print("Seed:")
print("\"", ''.join([int_to_char[value] for value in pattern]), "\"")
for i in range(1000):
    x = np.reshape(pattern, (1, len(pattern), 1))
    x = x / float(len(chars))
    prediction = model.predict(x, verbose=0)
    index = np.argmax(prediction)
    result = int_to_char[index]
    seq_in = [int_to_char[value] for value in pattern]
    sys.stdout.write(result)
    pattern.append(index)
    pattern = pattern[1:len(pattern)]

Dalam kod di atas, kami mula-mula membaca fail teks melalui perpustakaan io dan memetakan setiap aksara kepada integer unik. Kami kemudiannya membahagikan teks kepada jujukan dengan panjang 100 dan menukar jujukan ini kepada format yang sesuai untuk LSTM. Seterusnya, kami mentakrifkan model yang mengandungi dua lapisan LSTM dan lapisan bersambung sepenuhnya, menggunakan softmax sebagai fungsi pengaktifan untuk mengira taburan kebarangkalian aksara seterusnya. Akhir sekali, kami menggunakan kaedah muat untuk melatih model dan kaedah ramalan untuk menjana teks berterusan.

Apabila menggunakan model untuk menjana teks, kami mula-mula memilih secara rawak jujukan daripada set data sebagai titik permulaan. Kami kemudian menggunakan model untuk meramalkan taburan kebarangkalian aksara seterusnya dan memilih aksara dengan kebarangkalian tertinggi sebagai aksara seterusnya. Seterusnya, kami menambah aksara itu pada penghujung jujukan dan mengalih keluar aksara pada permulaan jujukan, mengulangi langkah di atas sehingga kami menjana 1000 aksara teks.

Secara amnya, LSTM ialah varian rangkaian saraf berulang yang direka khusus untuk menyelesaikan masalah pergantungan jangka panjang. Dengan menggunakan unit berpagar untuk mengawal aliran input, output dan keadaan dalaman, LSTM dapat mengelakkan masalah kecerunan lenyap atau meletup, membolehkan aplikasi seperti menjana teks berterusan.

Atas ialah kandungan terperinci Kaedah dan teknik untuk menghasilkan teks berterusan menggunakan LSTM. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!