Systémová príručka

Tento projekt je implementovaný tak, že samostatné skripty nezávisia jeden od druhého a môžu sa používať samostatne. Zdrojové kódy boli implementované v jazyku Python 3.6.10. Keras bol použitý na implementáciu ako hlavná knižnica.

Zdrojové súbory:

• Create_data.py

• Create Model.py

• Generate.py

• Create_data_2.py

• Perplexity.py

• requirements.txt

Create_data.py

Tento skript prijíma ako vstup súbor „input_data.txt“ obsahujúci textové údaje na trénovanie. Po dokončení sa vytvorí súbor „char_sequences.txt“ obsahujúci postupnosti znakov zo vstupného súboru.

Procesy

• Otvorenie a čítanie súboru. To sa vykonáva pomocou funkcie load_doc().

• Ďalšou fázou je príprava údajov. Počas prípravy sa z údajov odstránia všetky špeciálne znaky okrem medzier. Ďalej všetky ostatné znaky prevedené na malé písmená.

out = ""
for sim in raw_text:

    if 97 <= ord(sim.lower()) <= 122 or sim.lower() == ' ' or sim.lower() == '\n':
        out = out + sim.lower()

raw_text = out

tokens = raw_text.split()
raw_text = ' '.join(tokens)

• Z vyčistených údajov sa vytvoria postupnosti znakov. length - dĺžka sekvencie.

length = 10
sequences = list()
for i in range(length, len(raw_text)):
    # select sequence of tokens
    seq = raw_text[i - length:i + 1]
    # store
    sequences.append(seq)

• Hotové sekvencie sa uložia do súboru „char_sequences.txt“.

Create_Model.py

V tomto skripte sa vytvorí model a začína sa učenie neurónovej siete. Na vstupe skript dostane sekvenčný súbor „char_sequences.txt“. Na konci práce sa vytvoria dva súbory "model.h5" a "mapping.pkl". Vytvorí sa tiež súbor “log.csv”, v ktorom sa uložia výsledky metrík pre trénovanie.

Procesy

• Otvorenie a čítanie súboru. Vytvorí sa zoznam sekvencií.

in_filename = 'char_sequences.txt'
raw_text = load_doc(in_filename)
lines = raw_text.split('\n')

• Kódovanie, priradenie celočíselnej hodnoty každému pôvodnému znaku.

chars = sorted(list(set(raw_text)))
mapping = dict((c, i) for i, c in enumerate(chars))
sequences = list()
for line in lines:
    # integer encode line
    encoded_seq = [mapping[char] for char in line]
    # store
    sequences.append(encoded_seq)

• One-hot kódovanie.

sequences = [to_categorical(x, num_classes=vocab_size) for x in X]

• Tvorba modelu. Implementácia vrstiev, výber aktivačnej funkcie a početu neurónov.

model = Sequential()
model.add(LSTM(250, input_shape=(X.shape[1], X.shape[2]), return_sequences=True))
model.add(LSTM(250, return_sequences=True))
model.add((LSTM(250)))
model.add(Dense(vocab_size, activation='softmax'))

• Zostavenie modelu. Výber chybovej funkcie a optimalizatora.

model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

• Trénovanie modelu.

model.fit(X, y, epochs=30, verbose=2, callbacks=[csv_logger])

• Mapovanie a model sa uložia.

model.save('model.h5')
dump(mapping, open('mapping.pkl', 'wb'))

Generate.py

Tento skript generuje postupnosť znakov. Na vstupe sú dva súbory „model.h5“ a „mapping.pkl“, obsahujú stav vyškolenej natrénovanej siete a mapovanie (kódovanie znakov celočíselnými údajmi). Výstupom tohto skriptu sú vygenerované postupnosti znakov.

def generate_seq(model, mapping, seq_length, seed_text, n_chars):
    in_text = seed_text

    for _ in range(n_chars):
        encoded = [mapping[char] for char in in_text]
        encoded = pad_sequences([encoded], maxlen=seq_length, truncating='pre')
        encoded = to_categorical(encoded, num_classes=len(mapping))
        yhat = model.predict_classes(encoded, verbose=0)
        out_char = ''
        for char, index in mapping.items():
            if index == yhat:
                out_char = char
                break
        in_text += char
    return in_text

Tento skript obsahuje hlavnú funkciu „ generate_seq “, v ktorej sa uskutočňujú vyššie opísané procesy na kódovanie znakov a inverzné procesy na dekódovanie znakov. Na generovanie symbolov sa používa funkcia knižnice Keras „model.predict_classes“.

Create_data_2.py

Tento skript sa podobá na Create_data.py s jedným rozdielom, výsledkom budú pravidelné sekvencie, nie n-gramové sekvencie.

Perplexity.py

Účelom tohto skriptu je počítať perplexitu. Na vstupe tohto skriptu sú dva súbory "gen_seq.txt" a "test_seq.txt", obsahujúce sekvencie generované pomocou skriptu Create_data_2.py.

Procesy

• Odovzdanie súboru a jeho One-hot kódovanie.

def input_tensor(in_filename):
    # in_filename = 'char_sequences_1.txt'
    raw_text = load_doc(in_filename)
    lines = raw_text.split('\n')

    # integer encode sequences of characters
    chars = sorted(list(set(raw_text)))
    mapping = dict((c, i) for i, c in enumerate(chars))
    sequences = list()

    for line in lines:
        # integer encode line
        encoded_seq = [mapping[char] for char in line]
        # store
        sequences.append(encoded_seq)

    vocab_size = len(mapping)
    print('Vocabulary Size: %d' % vocab_size)

    # separate into input and output
    sequences = array(sequences)

    X = sequences[:, :-1]

    sequences = [to_categorical(x, num_classes=vocab_size) for x in X]

    X = array(sequences)

    return X

• Počítanie perplexity. cce = tf.keras.losses.CategoricalCrossentropy(tf.constant([1.]), tf.constant([0.001])) a = cce(Y, X).numpy() print("Perplexity: ", 2 ** a)

requirements.txt

Tento súbor bol vytvorený pomocou príkazu:

> pip freeze > requirements.txt

Tento súbor obsahuje všetky nainštalované balíčky pre projekt. To umožňuje inštaláciu všetkých balíkov pomocou príkazu:

> pip install -r requirements.txt