{"id":976,"date":"2023-02-01T09:24:15","date_gmt":"2023-02-01T09:24:15","guid":{"rendered":"https:\/\/web.htk.tlu.ee\/digitaru\/tarkvara2\/?post_type=chapter&p=976"},"modified":"2023-02-02T10:08:54","modified_gmt":"2023-02-02T10:08:54","slug":"piltide-klassifitseerimine","status":"publish","type":"chapter","link":"https:\/\/web.htk.tlu.ee\/digitaru\/tarkvara2\/chapter\/piltide-klassifitseerimine\/","title":{"raw":"Piltide klassifitseerimine","rendered":"Piltide klassifitseerimine"},"content":{"raw":"

Treeningandmete (piltide) leidmine\uf0c1<\/a><\/h2>\r\nSelleks, et masin saaks \u00f5ppida, kuidas \u00fcks v\u00f5i teine objekt v\u00e4lja n\u00e4eb, on tal vaja n\u00e4idisandmeid. Meie puhul see t\u00e4hendab, et treenimiseks on vaja koguda pilte. Mida rohkem n\u00e4idisandmeid on, seda paremini saab masin \u00f5ppida. Ei ole \u00fchest vastust, kui palju on piisav kogus mingi \u00fclesande jaoks. Me v\u00f5ime siin n\u00e4ite jaoks \u00f6elda, et 100 pilti on piisav, et mingisuguseid tulemusi juba saavutada. Aga vahepeal l\u00e4hevad need kogused miljonitesse. Teisest k\u00fcljest: mida rohkem on treeningandmeid (pilte), seda rohkem v\u00f5tab treenimine aega.\r\n\r\nLisaks kogusele on t\u00e4htis ka piltide sobivus. Pildid peaks olema \u00fcksteisest v\u00f5imalikult erinevad, et n\u00e4rviv\u00f5rk saaks n\u00e4ha erinevaid kujusid ja v\u00e4rve. Soovitatav on v\u00f5tta pildid, kus on v\u00f5imalikult v\u00e4he h\u00e4irivaid faktoreid. See aitab v\u00e4ltida olukorda, kus n\u00e4rviv\u00f5rk \u00f5pib selgeks vale omaduse, mida esineb sageli, kuid ei ole defineeriv pildi juures. Kui n\u00e4iteks treenida j\u00e4neseid tuvastama piltidelt, kus on alati porgand, siis v\u00f5ib n\u00e4rviv\u00f5rk \u00f5ppida tuvastama j\u00e4nese asemel hoopis porgandit.\r\n
\r\n

Lisainfo: Treeningandmete moonutamine<\/p>\r\n\r\n<\/header>\r\n

\r\n\r\nSamuti tasub proovida enne treenimist\u00a0treeningandmete moonutamist<\/a>\u00a0(venitamine, p\u00f6\u00f6ramine, m\u00fcra lisamine), et tulemuseks oleks t\u00f6\u00f6kindlam n\u00e4rviv\u00f5rk. See v\u00f5imaldab saada rohkem kasu samast pildist, sest igat pilti saab mitut eri moodi moonutada.\r\n\r\n<\/div>\r\n<\/div>\r\n

Andmete jagamine osadeks\uf0c1<\/a><\/h2>\r\nSelleks, et n\u00e4rviv\u00f5rku treenida ja tulemust kontrollida, on vaja andmed jagada osadeks ja m\u00e4\u00e4rata, millistel osadel treenitakse n\u00e4rviv\u00f5rku ja millistel osadel kontrollitakse tulemust. Kui seda mitte teha, v\u00f5ib n\u00e4rviv\u00f5rk lihtsalt k\u00f5ik andmed \"p\u00e4he tuupida\". Kui see juhtub, siis n\u00e4rviv\u00f5rk ei omanda \u00fcldistavat oskust ja ei \u00f5pi tundma andmetes olevaid mustreid. Selline n\u00e4rviv\u00f5rk on kasutu kui ta kohtab andmeid, mida ta pole varem p\u00e4he tuupinud. Selle \"p\u00e4he tuupimise\" n\u00e4htuse nimi on\u00a0\u00fclesobitamine<\/strong>\u00a0(overfitting<\/em>).\r\n\r\nAndmete osadeks jagamiseks on mitmeid erinevaid v\u00f5imalikke lahendusi. Siin tutvustame \u00fchte lihtsaimat, mis eeldab, et andmed jagatakse kaheks osaks: treeningandmestik (training set<\/em>) ja testandmestik (test set<\/em>).\r\n\r\nTreeningandmestik<\/strong>\u00a0(training set<\/em>) koosneb piltidest, mille peal n\u00e4rviv\u00f5rk \u00f5pib. Treeningandmed moodustavad enamuse kogu n\u00e4idisandmete hulgast. Neid pilte kasutab n\u00e4rviv\u00f5rk selleks, et leida optimaalsed neuronite kaalud.\r\n\r\nTestandmestik<\/strong>\u00a0(test set<\/em>) koosneb piltidest, mida kasutatakse l\u00f5pliku hinnangu andmiseks. Tegu on piltidega, mida n\u00e4rviv\u00f5rk pole siiani n\u00e4inud. Kuna need andmed pole treenimist m\u00f5jutanud, siis see aitab simuleerida reaalset olukorda, kus n\u00e4rviv\u00f5rk kohtab uusi andmeid. Nende andmete peal arvutatakse ka n\u00e4rviv\u00f5rgu l\u00f5plik t\u00e4psus.\r\n\r\nOsade suuruste jaoks puudub alati toimiv lahendus, kuid tihti kasutatakse treening- ja testiandmestiku suhteid nagu 90:10, 80:20 v\u00f5i 70:30. Mida v\u00e4hem on kogutud andmeid, seda rohkem s\u00f5ltub tulemus osade suurusest. Lisaks suurustele on t\u00e4htis ka sisu. Kui testandmed on liiga erinevad treeningandmetest, siis ei vasta testimistulemused treenimisele.\r\n
\r\n

Lisainfo: Andmegrupid<\/p>\r\n\r\n<\/header>\r\n

\r\n\r\nP\u00f5hjalikuma \u00fclevaate andmete gruppidest, kaasa arvatud metoodikatest, kus jagatakse andmeid kolmeks osaks, leiab siit<\/a>.\r\n\r\n<\/div>\r\n<\/div>\r\n

M\u00f5tle ja nuputa!<\/h2>\r\n[h5p id=\"47\"]\r\n

Andmete laadimine PyTorchi\uf0c1<\/a><\/h2>\r\nSelles \u00fclesandes kasutame me masin\u00f5ppekogukonnas populaarset andmekogumit CIFAR-10, mis on mugavalt otse l\u00e4bi PyTorchi saadav ning ette jagatud treenimis- ja testimisosadeks (l\u00e4bi\u00a0train<\/cite>\u00a0argumendi). Seal olevad pildid on piisavalt kvaliteetsed otseseks kasutamiseks. CIFAR-10 nimi tuleneb sellest, et ta pildid jagunevad k\u00fcmnesse erinevasse klassi.\r\n\r\n[caption id=\"attachment_984\" align=\"alignnone\" width=\"595\"]\"CIFAR-10 Pildi allikas: https:\/\/www.cs.toronto.edu\/~kriz\/cifar.html[\/caption]\r\n\r\nT\u00e4ielikku nimekirja PyTorchi poolt (p\u00f5hiliselt \u00f5ppe- ja uuringeesm\u00e4rkidel) pakutavatest andmekogumitest saab vaadata siit<\/a>. CIFAR-10 pildid saab k\u00e4tte (automaatse internetist allalaadimisega) kasutades\u00a0DataSet<\/span><\/code>-i niiviisi:\r\n
from torchvision import datasets, transforms\r\n\r\ntrain_data = datasets.CIFAR10(\r\n    root='data',  # kaust, kuhu andmed laetakse alla\r\n    train=True,   # kas soovime treeningandmeid (True) v\u00f5i testimisandmeid (False)\r\n    download=True,   # kas laeme vajadusel andmed automaatselt alla internetist\r\n    transform=transforms.ToTensor()  # teisendame pildid tensoriteks\r\n)\r\ntest_data = datasets.CIFAR10(\r\n    root='data',\r\n    train=False,\r\n    download=True,\r\n    transform=transforms.ToTensor()\r\n)\r\n\r\nx, y = next(iter(train_data))  # v\u00f5tame treenimisandmetest esimese pildi\r\nprint(x.shape)  # torch.Size([3, 32, 32]) - 3 v\u00e4rvikanalit (RGB), 32x32 pikslit\r\nprint(y)  # 6 - pildi klass<\/pre>\r\n
\r\n
Lisainfo: Enda piltide laadimine<\/p>\r\n\r\n<\/header>\r\n
\r\n\r\nJuhul kui meil on olemas oma enda pildid, saame kasutada klassi\u00a0ImageFolder<\/span><\/code>\u00a0(dokumentatsiooni saab lugeda\u00a0siit<\/a>). Sellele klassile tuleb anda kaust, kus on eraldi kaustad iga klassi jaoks, ning igas klassikaustas on antud klassi (y)<\/code> kuuluvad pildid (x<\/code>). Selles \u00fclesandes piirdume ainult CIFAR-10-ga.\r\n\r\n<\/div>\r\n<\/div>\r\nKuigi \u00fcleval on toodud v\u00e4lja n\u00e4ide, kuidas pilte\u00a0DataSet<\/span><\/code>-ist \u00fche kaupa k\u00e4tte saada, on soovituslik lisaks sellele kasutada PyTorchi poolt pakutavat\u00a0DataLoader<\/span><\/code>-it, mis v\u00f5imaldab andmeid laadida suvalises j\u00e4rjekorras ja mitme kaupa (miniplokkides, ingl.k. minibatches<\/em>), t\u00e4nu millele muutub treenimisprotsess efektiivsemaks.\u00a0DataLoader<\/span><\/code>-i kasulikest omadustest saab rohkem lugeda\u00a0siit<\/a>.\r\n
from torch.utils.data import DataLoader\r\n\r\ntrain_loader = DataLoader(train_data, batch_size=16, shuffle=True)\r\ntest_loader = DataLoader(test_data, batch_size=16, shuffle=True)\r\n\r\nx, y = next(iter(train_loader))  # v\u00f5tame miniploki\r\nprint(x.shape)  # torch.Size([16, 3, 32, 32]) - 16 pilti, 3 v\u00e4rvikanalit (RGB), 32x32 pikslit\r\nprint(y.shape)  # torch.Size([16]) - 16 m\u00e4rgendit (klassi, kuhu miniploki pildid kuuluvad)<\/pre>\r\nMitu pilti korraga \u00fchte miniplokki laetakse on m\u00e4\u00e4ratud l\u00e4bi\u00a0batch_size<\/cite>\u00a0argumendi; t\u00fc\u00fcpiliselt on see 32 v\u00f5i 64, siin piirdume 16-ga. N\u00e4rviv\u00f5rgu parameetreid uuendatakse vaid \u00fche korra iga miniploki l\u00f5pus l\u00e4bi iga pildi ennustuse summeeritud kahju. Argument\u00a0shuffle=True<\/span><\/code>\u00a0t\u00e4hendab seda, et andmeid antakse suvalises j\u00e4rjekorras.\r\n\r\n \r\n\r\n[caption id=\"attachment_985\" align=\"alignnone\" width=\"674\"]\"\" \u00dcks v\u00f5imalik CIFAR-10 kahjufunktsioonimaastiku visualisatsioon (interaktiivne versioon on saadaval http:\/\/www.telesens.co\/loss-landscape-viz\/viewer.html). Pildi allikas: https:\/\/www.cs.umd.edu\/~tomg\/projects\/landscapes\/[\/caption]\r\n
PyTorchi n\u00e4rviv\u00f5rgumoodul\uf0c1<\/a><\/h2>\r\nSelles peat\u00fckis v\u00f5tame kokku k\u00f5ik olemasolevad detailid ja hakkame ehitama lihtsat n\u00e4rviv\u00f5rgu, mis oskab klassifitseerida CIFAR-10 pilte. Treenimiseks kasutame PyTorchi poolt pakutavat\u00a0nn.Module<\/span><\/code>\u00a0klassi, mis lihtsustab n\u00e4rviv\u00f5rkude koostamist. Suurem osa koodist j\u00e4\u00e4b samaks, nagu varasemates n\u00e4idetes.\r\n
\r\n
\r\n
from torch import nn\r\n\r\nclass NeuralNetwork(nn.Module):  # anname nn.Module-ile nime \"NeuralNetwork\"\r\n    def __init__(self):\r\n        super().__init__()  # vajalik rida nn.Module-i kasutamiseks!\r\n\r\n    def forward(self, x):\r\n        print(x.shape)  # torch.Size([16, 3, 32, 32]) - 16 pilti, 3 v\u00e4rvikanalit (RGB), 32x32 pikslit<\/pre>\r\nEt\u00a0nn.Module<\/span><\/code>-it kasutada, pole vaja teada klassidest palju. Peamine detail on see, et\u00a0__init__<\/span><\/code>\u00a0meetodis tuleb luua k\u00f5ik kihid ning\u00a0forward<\/span><\/code>\u00a0meetodis tuleb kirjeldada, kuidas andmed neid kihte l\u00e4bivad.\r\n\r\nDeklareerime mooduli kihid pannes kihimuutujate nimede ette\u00a0self.<\/span><\/code>\u00a0(t\u00e4nu sellele saame neid kasutada\u00a0forward<\/span><\/code>\u00a0meetodis j\u00e4lle l\u00e4bi\u00a0self<\/span><\/code>\u00a0parameetri):\r\n
def __init__(self):\r\n    super().__init__()  # vajalik rida nn.Module-i kasutamiseks!\r\n\r\n    self.hidden_layer = nn.Linear(3 * 32 * 32, 30)  # 32x32x3 pikslit, 30 v\u00e4ljundit\r\n    self.sigmoid = nn.Sigmoid()  # aktivatsioonifunktsioon peidetud kihile\r\n    self.output_layer = nn.Linear(30, 10)  # 30 sisendit, 10 v\u00e4ljundit (\u00fcks iga klassi kohta)\r\n    self.softmax = nn.Softmax(dim=1)  # aktivatsioonifunktsioon v\u00e4ljundkihile<\/pre>\r\nViimasel real\u00a0self.softmax<\/span>\u00a0=<\/span>\u00a0nn.Softmax(dim=1)<\/span><\/code>\u00a0m\u00e4\u00e4rab argument\u00a0dim=1<\/span><\/code>\u00a0\u00e4ra, et\u00a0softmax<\/span><\/code>\u00a0rakendataks iga pildi kohta eraldi. See on vajalik, kuna me kasutame miniplokke, mille puhul antakse meile\u00a0x<\/span><\/code>-i 16 pilti korraga. Aktivatsioonifunktsioon\u00a0nn.Softmax<\/span><\/code>\u00a0viib v\u00e4ljundkihi neuronid kujule kus nende kogusumma on 1, mis v\u00f5imaldab neid v\u00e4\u00e4rtusi interpreteerida piltide klassi kuuluvuse t\u00f5en\u00e4osustena (n\u00e4rviv\u00f5rgu \"ennustuseks\" loeme suurima t\u00f5en\u00e4osusega klassi). N\u00e4iteks:\r\n
data = torch.tensor([5.5, 3.5, 4.2])\r\nactivation_fn = nn.Softmax()\r\nprint(activation_fn(data))  # tensor([0.7103, 0.0961, 0.1936]) - 71%, 10%, 19%<\/pre>\r\nN\u00fc\u00fcd kui kihimuutujad on deklareeritud, kirjeldame, kuidas andmed neid kihte l\u00e4bivad iga\u00a0x<\/span><\/code>-i korral:\r\n
def forward(self, x):\r\n    x = x.flatten(start_dim=1)  # 16x3x32x32 -> 16x3072\r\n    z_1 = self.hidden_layer(x)  # 16x3072 -> 16x30\r\n    a_1 = self.sigmoid(z_1)  # 16x30 -> 16x30\r\n    z_2 = self.output_layer(a_1)  # 16x30 -> 16x10\r\n    a_2 = self.softmax(z_2)  # 16x10 -> 16x10\r\n    return a_2<\/pre>\r\nEsimene\u00a0x<\/span><\/code>-i transformeeriv rida\u00a0x<\/span>\u00a0=<\/span>\u00a0x.flatten(start_dim=1)<\/span><\/code>\u00a0on vajalik, sest\u00a0nn.Linear<\/span><\/code>\u00a0ootab sisendandmeid 1D-kujul, v\u00e4lja arvatud esimene miniplokkide dimensioon (indeks 0), millega tegeleb\u00a0nn.Linear<\/span><\/code>\u00a0automaatselt. Argument\u00a0start_dim=1<\/span><\/code>\u00a0t\u00e4hendab seda, et tensori lamestamisel esimest dimensiooni ignoreeritakse (lamestamist alustatakse indeks 1 dimensiooniga). N\u00fc\u00fcd kui\u00a0x<\/span><\/code>\u00a0on \u00f5igel kujul, l\u00e4bivad andmed peidetud kihist v\u00e4ljundkihini, kus l\u00f5plik tulemus tagastatakse.\r\n\r\n[caption id=\"attachment_986\" align=\"alignnone\" width=\"719\"]\"N\u00e4rviv\u00f5rgu Meie n\u00e4rviv\u00f5rgu visualiseeritud struktuur. Pilt autori koostatud.[\/caption]\r\n
Epohhid ja n\u00e4rviv\u00f5rgu treenimine\uf0c1<\/a><\/h2>\r\nN\u00e4rviv\u00f5rgu treenimisprotsess koosneb epohhitest (epoch<\/em>). Epohhi jooksul k\u00e4iakse treeningandmed \u00fche korra l\u00e4bi. Treenimine koosneb tavaliselt rohkem kui \u00fches epohhist. Kui teha liiga palju epohhe, siis tekib \u00fcletreenimise oht, sest n\u00e4rviv\u00f5rgule antakse piisavalt aega andmetele \u00fclesobituda.\r\n\r\nLoome n\u00e4rviv\u00f5rgu instantsi, koostame MSE kahjufunktsiooni ja m\u00e4\u00e4rame optimeerija \u00f5pisammuga 0.1:\r\n
net = NeuralNetwork()\r\nloss_fn = nn.MSELoss()\r\noptimizer = torch.optim.SGD(net.parameters(), lr=0.1)<\/pre>\r\n
\r\n
Lisainfo: CUDA kasutajatele<\/p>\r\n\r\n<\/header>\r\n
\r\n\r\nJuhul kui oled siiamaani kasutanud CUDA-t, tuleb m\u00e4\u00e4rata ka\u00a0nn.Module<\/span><\/code>-i seadme:\u00a0net<\/span>\u00a0=<\/span>\u00a0NeuralNetwork().to(device)<\/span><\/code>. Seade rakendub k\u00f5ikidele kihtidele, mis on deklareeritud antud class<\/span>\u00a0NeuralNetwork(nn.Module)<\/span><\/code>-i sees.\r\n\r\n<\/div>\r\n<\/div>\r\nJ\u00e4rgmisena hakkame kirjutama ts\u00fcklit, mis treenib n\u00e4rviv\u00f5rku 10 epohhit:\r\n
for epoch in range(10):\r\n    for x, y in train_loader:  # k\u00e4ime l\u00e4bi k\u00f5ik miniplokid\r\n        y_hat = net(x)  # teeme ennustuse\r\n        print(y.shape, y_hat.shape)  # torch.Size([16]) torch.Size([16, 10])\r\n\r\n        optimizer.zero_grad()  # nullime eelnevad gradiendid\r\n        loss = loss_fn(y_hat, y)  # arvutame kahju\r\n        # error! y ja y_hat on erineva kujuga, seega ei saa kahju arvutada<\/pre>\r\nSiin tekib probleem! Muutuja\u00a0y<\/span><\/code>\u00a0on kujul\u00a0[2,<\/span>\u00a05,<\/span>\u00a0...,<\/span>\u00a01,<\/span>\u00a05]<\/span><\/code>, muutuja\u00a0y_hat<\/span><\/code>\u00a0aga kujul\u00a0[[0.1,<\/span>\u00a00.2,<\/span>\u00a0...,<\/span>\u00a00.5],<\/span>\u00a0[0.4,<\/span>\u00a00.1,<\/span>\u00a0...,<\/span>\u00a00.1],<\/span>\u00a0...,<\/span>\u00a0[0.0,<\/span>\u00a00.7,<\/span>\u00a0...,<\/span>\u00a00.2]]<\/span><\/code>. Esimeses on tegemist \u00f5igete klasside indeksitega, teises aga ennustatud klasside t\u00f5en\u00e4osustega. Et kahjufunktsioon t\u00f6\u00f6taks, peame muutma\u00a0y<\/span><\/code>\u00a0samale kujule nagu\u00a0y_hat<\/span><\/code>. N\u00e4iteks kui\u00a0y[0]<\/span><\/code>\u00a0on\u00a02<\/span><\/code>, peaks temast saama vektor\u00a0[0,<\/span>\u00a00,<\/span>\u00a01,<\/span>\u00a00,<\/span>\u00a00,<\/span>\u00a00,<\/span>\u00a00,<\/span>\u00a00,<\/span>\u00a00,<\/span>\u00a00]<\/span><\/code>. Kuigi saaksime teoorias kirjutada selle probleemi lahendamiseks enda koodi, pakub PyTorch mugavat funktsiooni\u00a0nn.functional.one_hot<\/span><\/code>, mis teeb terve t\u00f6\u00f6 \u00e4ra meie eest:\r\n
for x, y in train_loader:  # k\u00e4ime l\u00e4bi k\u00f5ik miniplokid\r\n    y_hat = net(x)  # teeme ennustuse\r\n\r\n    y = nn.functional.one_hot(y, 10).to(torch.float)  # muudame y-i \u00f5igele kujule (10 klassi)\r\n    optimizer.zero_grad()  # nullime k\u00f5ik varasemad gradiendid\r\n    loss = loss_fn(y_hat, y)  # arvutame kahju<\/pre>\r\nN\u00fc\u00fcd kui kahju on arvutatud, peame me ka arvutama, kuidas see kahju m\u00f5jutab iga parameetri (w<\/code>) v\u00e4\u00e4rtust l\u00e4bi funktsiooni\u00a0loss.backward()<\/span><\/code>. See funktsioon arvutab gradiendid ja salvestab nad kihtide sisse. Ja l\u00f5puks kasutame optimeerijat, et muuta kaalufaktoreid vastavalt gradiendile.\r\n
loss.backward()  # leiame, kui palju peame muutma iga kihi parameetrit, et kahju oleks v\u00e4iksem\r\noptimizer.step()  # teeme sammu optimeerija abil (muudame kaale vastavalt gradiendile)<\/pre>\r\nNing sellega on meie treeningprotsess valmis.\r\n\r\n[caption id=\"attachment_987\" align=\"alignnone\" width=\"371\"]\"Machine Pildi allikas: https:\/\/xkcd.com\/1838\/[\/caption]\r\n\r\n<\/div>\r\n
N\u00e4rviv\u00f5rgu testimine\uf0c1<\/a><\/h2>\r\nKui tahame n\u00e4ha, kui h\u00e4sti meie n\u00e4rviv\u00f5rk t\u00f6\u00f6tab, siis saame selleks kasutada testimisandmeid. Igas epohhis k\u00e4ime algselt l\u00e4bi k\u00f5ik treeningandmed (for<\/span>\u00a0x,<\/span>\u00a0y<\/span>\u00a0in<\/span>\u00a0train_loader<\/span><\/code>) ja siis k\u00f5ik testimisandmed (for<\/span>\u00a0x,<\/span>\u00a0y<\/span>\u00a0in<\/span>\u00a0test_loader<\/span><\/code>).\r\n\r\nTestimisandmete ts\u00fckkel erineb selle poolest, et me ei tee optimeerimist (ei muuda kaale \/ treeni n\u00e4rviv\u00f5rku). T\u00e4nu sellele ei saa n\u00e4rviv\u00f5rk testiandmed \"meelde j\u00e4tta\": simuleerime reaalse elus olukorda, kus me ei tea, millised andmed meile tulevad. Kui me seda ei teeks, oleks meil v\u00f5imatu teada kui h\u00e4sti n\u00e4rviv\u00f5rk reaalselt oskab meie probleemi mustreid generaliseerida.\r\n\r\nTreenimise v\u00e4ltimiseks j\u00e4tame \u00e4ra read\u00a0loss.backward()<\/span><\/code>,\u00a0optimizer.zero_grad()<\/span><\/code>\u00a0ja\u00a0optimizer.step()<\/span><\/code>. Olenedes statistikatest mis meid huvitavad, v\u00f5ime \u00e4ra j\u00e4tta ka l\u00f5pliku kahju arvutamise (loss_fn(y_hat,<\/span>\u00a0y)<\/span><\/code>).\r\n\r\nLisaks sellele ei pea me ka taustas arvutama gradiente, mida muidu\u00a0tehakse PyTorchis vaikimisi<\/a>. Et gradientide arvutamist v\u00e4ltida, peame panema oma koodi\u00a0with<\/span>\u00a0torch.no_grad()<\/span><\/code>\u00a0konteksti:\r\n
for epoch in range(10):\r\n    for x, y in train_loader:\r\n        ...  # sama kood, mis varem\r\n\r\n    with torch.no_grad():  # me ei soovi arvutada gradiente\r\n        for x, y in test_loader:  # k\u00e4ime l\u00e4bi k\u00f5ik miniplokid\r\n            y_hat = net(x)  # teeme ennustuse\r\n\r\n            y = nn.functional.one_hot(y, 10).to(torch.float)  # muudame y-i \u00f5igele kujule (10 klassi)\r\n            loss = loss_fn(y_hat, y)  # arvutame kahju statistika jaoks<\/pre>\r\nN\u00fc\u00fcd on meie treenimiskood palju kiirem, sest me ei arvuta enam m\u00f5ttetult gradiente.\r\n\r\nJ\u00e4rgmine samm on hakata arvutama statistikaid nii treenimis- kui ka testimisandmete peal. M\u00f5lema m\u00f5\u00f5tmine on t\u00e4htis selle jaoks, et m\u00e4rgata \u00fclesobitamist. \u00dclesobitamise selgeim s\u00fcmptom on k\u00f5rge \u00f5igsus (\u00f5igete ennustuste protsent; ingl.k.\u00a0accuracy<\/em>) treeningandmete peal, kuid tunduvalt madalamatesse \u00f5igsus testimisandmete peal. Kui n\u00e4rviv\u00f5rk t\u00f6\u00f6tab h\u00e4sti, siis on \u00f5igsus k\u00f5rge nii treening- kui ka testimisandmetel.\r\n\r\nKuna meie koodis tulevad igas epohhis testimisandmed p\u00e4rast treeningandmeid, siis epohhi-keskse n\u00e4rviv\u00f5rgu \u00f5ppimise t\u00f5ttu v\u00f5ib testimisandmete \u00f5igsus tulla k\u00f5rgem kui treeningandmete \u00f5igsus.\r\n
\r\n
Lisainfo: \u00dclesobitamise p\u00f5hjused<\/p>\r\n\r\n<\/header>\r\n
\r\n\r\n\u00dclesobitamist saab tekitada n\u00e4iteks:\r\n