ML v Pythone 11 – vytvorenie a učenie neurónovej siete na generovanie poviedok

Ako na to

29.8.2023

Ukážeme vytvorenie a natrénovanie vlastnej neurónovej siete. Natrénujeme ju texte knihy. V reálnej praxi by sa trénovala na tisíckach kníh a ďaľších textov. Následne túto neurónovú sieť použijeme na generovanie textu krátkej poviedky. Zadáte prvých päť slov a algoritmus bude generovať ďalšie slová poviedky.

V predchádzajúcej časti sme ukázali načítanie textu knihy, prevod na slová a vyčistenie od neabecedných znakov. Na natrénovanie použili knihu Rivers of Babylon od Petra Pišťanka, ktorú máme na Google disku v súbore Rivers of Babylon.txt. Aby bol kód v tomto článku kompletný uvedieme aj kód na načítanie knihy a vyčistenie textu

#načítanie knihy z Google drive

from google.colab import drive

drive.mount('/content/drive')

kniha1 = open('/content/drive/My Drive/ML Neuronova siet/Rivers of Babylon.txt', 'r')

kniha1 = kniha1.read()

import nltk

nltk.download('punkt')

from nltk.tokenize import word_tokenize

slova = word_tokenize(kniha1.lower())

import string

zoznam_slov = []

neabecedne_znaky = string.punctuation

neabecedne_znaky

for slovo in slova:

for char in slovo:

if char in neabecedne_znaky:

slovo = slovo.replace(char, "")

if slovo not in neabecedne_znaky:

zoznam_slov.append(slovo)

print("Počet slov:", len(zoznam_slov), "unikátnych", len(set(zoznam_slov)))

slovnik= set(zoznam_slov) #unikátne slová

print("Slovník obsahuje", len(zoznam_slov),"slov, unikátnych slov je", len(slovnik))

indexy_slov = {slovo: i for i, slovo in enumerate(slovnik)}

zoznam_indexov_slov = [indexy_slov[slovo] for slovo in zoznam_slov]

davka=5

pocet_slov = len(zoznam_slov) #pocet slov knihy

trenovacia_mnozina = [([zoznam_indexov_slov[i], zoznam_indexov_slov[i+1], zoznam_indexov_slov[i+2], zoznam_indexov_slov[i+3], zoznam_indexov_slov[i+4]], zoznam_indexov_slov[i+5]) for i in range(pocet_slov-davka) ]

Takže toľko kompletný kód z minulého dielu, kde bol aj podrobne vysvetlený. Aby článok nebol príliš dlhý tak v tejto časti uvedieme len kódy na vytvorenie a natrénovanie NS a na predpoveď, vrátane zadávania prvých päť slov poviedky a generovania jej textu

Trénovaciu množinu máme pripravenú, môžeme sa pustiť do definovania a trénovania neurónovej siete.Postup:

načítanie vstupných dát a prvotná inicializácia váh,
pre vopred zvolený počet iterácií sa vykonajú nasledovné kroky:

posun vpred forward pass,
spätná propagácia,
úprava váh na základe gradientnej metódy,

Potom bude nasledovať otestovanie úspešnosti klasifikácie

Posun vpred (forward)pri predpovedaní informácie prúdia zo vstupu cez skryté vrstvy na výstup , čiže po predikciu výsledku. Na každom neuróne sa vstupy, čiže výstupy predchádzajúcich uzlov vynásobia príslušnými váhami spojení a následne sa sčítajú. Na záver sa aplikuje aktivačná funkcia neurónu. V našom prípade ako aktivačnú funkciu využijeme funkciu ReLu

Spätná propagácia – (backward propagation) rieši úpravu váh neurónových spojení tak, aby neurónová sieť poskytovala výstup, ktorý je bližší k požadovanému výsledku, čiže minimalizujeme stratovú funkciu. Tento proces prebieha opačne od výstupov k vstupom. Ako prvý sa vypočíta gradient váh poslednej výstupnej vrstvy a ako posledný sa vypočíta gradient váh prvej vrstvy. Výsledky výpočtu gradientu z príslušnej vrstvy sa použijú pri výpočte gradientu pre predchádzajúcu vrstvu.

Najskôr uvedieme kompletný kód na vytvorenie triedy modelu, funkcie trénovania a kód na zadanie prvých piatich slov poviedky a v bydúcom pokračovaní vysvetlíme akú činnosť vykonávajú použité funkcie

import torch

import torch.nn as nn

import torch.nn.functional as F

import torch.optim as optim

import time

embedding_dim = 5 #veľkosť embedding vektorov

# === Trieda definujúca model neurónovej siete ===

# Embedding (vložená vrstva) je skrytá vrstva NS ktorá

# mapuje vstupné informácie z vysoko do nízko rozmerného priestoru

class Model_NS(nn.Module):

def __init__(self, pocet_slov, embedding_dim, davka):

super(Model_NS, self).__init__()

self.embeddings = nn.Embedding(pocet_slov, embedding_dim)

self.linear1 = nn.Linear(davka * embedding_dim,128) # lineárne transformácie ako vrstvy NS

self.linear2 = nn.Linear(128, 512)

self.linear3 = nn.Linear(512, pocet_slov)

# pri predpovedaní informácie prúdia „dopredu“

# zo vstupu cez skryté vrstvy na výstup

# výstupom sú logaritmy pravdepodobností

def forward(self, inputs): # pri predpovedaní

embs = self.embeddings(inputs).view((1,-1))

out = F.relu(self.linear1(embs)) #lineárna aktivačná funkcia

out = F.relu(self.linear2(out))

out = self.linear3(out)

log_pravdepodobnosti = F.log_softmax(out, dim=1) #konvertuje číselné hodnoty na pravdepodobnosti

return log_pravdepodobnosti

Zistíme parametre modelu neurónovej siete

# výpis parametrov modelu

model = Model_NS(pocet_slov, embedding_dim, davka)

print(model.embeddings,"\n")

model

---výpis---

Embedding(90374, 5)

Model_NS(

(embeddings): Embedding(90374, 5)

(linear1): Linear(in_features=25, out_features=128, bias=True)

(linear2): Linear(in_features=128, out_features=512, bias=True)

(linear3): Linear(in_features=512, out_features=90374, bias=True)

)

Trénovanie modelu

# === trénovanie modelu ===

from torch.cuda import is_available

# Pokiaľ možno na GPU

if torch.cuda.is_available():

device = torch.device("cuda:0")

else:

device = torch.device("cpu")

priebezne_chyby = [] # chyby po každých 1000 krokoch trénovania

def trenovanie(model, trenovacie_data, n_iteracie, word_to_index):

model.to(device)

for i in range(n_iteracie):

model.train()

krok = 0

perioda_vypisu = 1000

akumulovana_chyba = 0 # na výpočet priemernej chyby po každých 1000 krokoch

for feature, target in trenovacie_data:

feature_tensor = torch.tensor([feature], dtype=torch.long)

feature_tensor = feature_tensor.to(device)

target_tensor = torch.tensor([target], dtype=torch.long)

target_tensor = target_tensor.to(device)

model.zero_grad() #vynulovanie gradientov

log_probs = model(feature_tensor)

loss = criterion(log_probs, target_tensor)

loss.backward() #Spätný prechod pri aktualizácii parametrov

optimizer.step()

akumulovana_chyba += loss.item()

krok+=1

if krok % perioda_vypisu == 0: #každých 1000 krokov

model.eval()

priemerna_chyba = akumulovana_chyba/perioda_vypisu

priebezne_chyby.append(priemerna_chyba) #pridám do zoznamu

print(i+1,"z",n_iteracie, "iterácií", krok,"krok z",pocet_slov,

"Chyba: {:.3f}".format(priemerna_chyba))

akumulovana_chyba=0

model.train()

return model

Spustenie trénovania pre daný počet iterácií

model = Model_NS(pocet_slov, embedding_dim, davka)

criterion = nn.NLLLoss()

optimizer = optim.SGD(model.parameters(),lr=0.01)

n_iteracie = 2

start_time = time.time()

model = trenovanie(model, trenovacia_mnozina, n_iteracie, indexy_slov)

print("Trénovanie modelu trvalo {} minút".format(round((start_time - time.time())/60),2))

# Doplnenie modelu

model.average_loss = priebezne_chyby

model.optimizer_state = optimizer.state_dict()

model.word_to_index = indexy_slov,

model.index_to_word = {i: word for i, word in enumerate(slovnik)}

Graf priebežných chýb počas trénovania

import pandas as pd

loss_plot = pd.DataFrame(priebezne_chyby)

loss_plot.plot()

Funkcia na predpovedanie slov poviedky

import pandas as pd

import random

def predpoved(model, zaciatok_poviedky ,dlzka_poviedky ,top_slova):

# top_slova - slovo sa vyberie náhodne z top_k počtu

# Prvých 5 slov do poviedky

vstupy = (zaciatok_poviedky.lower()).split(" ") # Prvých 5 slov

for i in vstupy:

poviedka.append(i)

for i in range(dlzka_poviedky):

# slová na čísla (indexy)

vstupy_ix = torch.tensor([indexy_slov[word] for word in vstupy], dtype=torch.long)

vstupy_ix = vstupy_ix.to(device)

with torch.no_grad(): # nevoláme Tensor.backward() nemusíme počítať gradienty

output = model.double().forward(vstupy_ix)

ps = torch.exp(output)

top_kombinacia_indexy = ps.topk(top_slova, sorted=True)

#top_n najpravdepodobnejších slov

topk_ps = top_kombinacia_indexy[0][0]

top_ntica = top_kombinacia_indexy[1][0]

top_ntica = [model.index_to_word[int(i)] for i in top_ntica]

# náhodný výber slova z top_n

next_word = random.choice(top_ntica)

vstupy = vstupy[1:] # pridanie slova do vstupov a posunutie

vstupy.append(next_word)

poviedka.append(next_word) # pridanie slova do poviedky

return poviedka

Generovanie poviedky

zaciatok_poviedky = input('Zadaj prvých {} slov poviedky:\n'.format(davka))

top_slova = 3 # Slovo sa vyberie náhodne z top_k počtu

dlzka_poviedky = 20

poviedka = []

if torch.cuda.is_available():

device = torch.device("cuda:0")

else:

device = torch.device("cpu")

# osetrenie vstupu, treba zadať 5 slov, ktoré model pozná

try:

predikcia = predpoved(model, zaciatok_poviedky, dlzka_poviedky, top_slova)

except KeyError as error:

print('niektorému zo slov zatiaľ nerozumiem\n zadaj slová z kníh na ktorých som sa učil nie ', error)

if poviedka[0] != "":

poviedka = poviedka[len(zaciatok_poviedky):]

zaciatok_poviedky = input('zadaj slová ktorým rozumiem\n')

predikcia = predpoved(model, zaciatok_poviedky, dlzka_poviedky, top_slova)

except KeyError and RuntimeError:

if poviedka[0] != "":

poviedka = poviedka[len(zaciatok_poviedky):]

zaciatok_poviedky = input('Zadal si {} slov namiesto {}!\n\nZadaj presný počet slov\n'.format(len(zaciatok_poviedky.split(" ")), 5))

predikcia = predpoved(model, zaciatok_poviedky, dlzka_poviedky, top_slova)

print('\n=== Poviedka ===')

print(" ".join(poviedka))

Vygenerovaný text po dvoch iteráciách trénovania po zadaní piatich slov:“ obloha čoraz častejšie dostáva farbu“

obloha čoraz častejšie dostáva farbu na nich a po sa do tmy rácz sa z svoju a už si s z a rácz sa mu do vily za sa a rácz na všetko do tmy rácz je rácz až a rácz sa do svoju rácz sa už do na hodinky sa už sa na svoju

Vygenerovaný text po desiatich iteráciách trénovania po zadaní rovnakých prvých piatich slov

obloha čoraz častejšie dostáva farbu na nevinných no trolejbusom do vily že ho do nechápavo až vám keď nesie oblokom fitness že kvapku rácz s prsty ktorý stisnúť alebo jemu veď až na všetko fredyho a o ústam vzrušenia hneď rácz si sa necítia sebou pred sebou sa však a už dávno opäť stučnel stáť

Po ďalšom spustení vznikne iný text

obloha čoraz častejšie dostáva farbu pred všetkých života o hotelovej veľa rácz mohol rácz vzdiali ako sám niekedy strach s sa platnosťou že za slobodu a čo si chceli rácz sem no kedysi že nemá to že si sa im skončí lesknú a pozerá si dnes stôl každý mu nikdy pred svoju sa stane naučil

V budúcom pokračovaní podrobne popíšeme funkcie použité na vytvorenie a trénovvanie neurónovej siete a na generovanie textu

Rekapitulácia doterajších dielov

Strojové učenie v Pythone 1 – prostredie Google Colab

Strojové učenie v Pythone 2 – knižnica Pandas na prácu s údajmi

ML v Pythone 3 – export a import údajov vo formáte CSV a Excel

Strojové učenie v Pythone 4 – práca s údajmi

ML v Pythone 5 – vizualizácia údajov pomocou grafov

ML v Pythone 6 – animované grafy a ich export ako video

ML v Pythone 7 – Využitie grafickej karty NVIDIA na výpočtovo náročné úlohy

ML v Pythone 8 – príklad rozpoznávanie obrazu

ML v Pythone 9 – trénovanie neurónu

ML v Pythone 10 – trénovanie neurónovej siete, príprava