Învățare automată Laborator 9 Rețele neuronale în TensorFlow TensorFlow (abreviat TF) este o bibliotecă open source ce permite efectuarea de calcule ș

Transcriere

1 Rețele neuronale în TensorFlow TensorFlow (abreviat TF) este o bibliotecă open source ce permite efectuarea de calcule și procesări numerice de mare performanță. Punctul forte al acestei bilblioteci îl constituie implementarea de algoritmi de machine learning, în special rețele neuronale de mare complexitate, cum sunt cele din domeniul deep learning. Partea funcțională a TF este implementată în C++ și CUDA, în timp ce API-ul cel mai frecvent utilizat este creat în limbajul Python (API = Application Programming Interface colecția de clase/funcții/interfețe cu ajutorul cărora exploatăm funcționalitatea unui framework sau a unei biblioteci). Așadar, în TF se programează folosind Python, dar procesarea efectivă se realizează de către un engine dezvoltat in C++ / CUDA. Un program TF are două componente esențiale: - un model, ce conține totalitatea operațiilor ce se doresc a se efectua, precum și a datelor (tensorilor) ce se doresc a fi determinate. Modelul se implementează folosind o structură de tip graf, ce conține succesiunea de execuție a operațiilor și de evaluare a tensorilor (i.e. de determinare a valorilor variabilelor modelului). Acest graf este realizat conform principiului de programare data flow, de unde și denumirea de TensorFlow o bibliotecă ce prelucrează tensori folosind operații structurate pe principiul data flow (pentru simplificare, prin tensor înțelegem un array multidimensional scalar, vector, matrice 2D, 3D etc.) - o sesiune obiect ce permite execuția parțială sau completă a modelului menționat anterior. În cadrul unei sesiuni se rezolvă problema dorită cu ajutorul modelului definit în prealabil. Un exemplu simplu: a = tf.constant(2) b = tf.constant(3) print(c) Dacă rulăm exemplul, observăm că nu se afișează valoarea lui c, ci un mesaj de tipul: Tensor("add:0", shape=(), dtype=int32) Ceea ce constituie tipul de dată al lui c. Valoarea lui c nu s-a calculat încă, deoarece în această etapă tot ceea ce am făcut a fost să definim modelul aplicației. Momentan nu se execută nimic și nu se fac calcule. Valoarea lui c se determină în cadrul unei sesiuni, astfel: 1

2 a = tf.constant(2) b = tf.constant(3) sess = tf.session() result = sess.run(c) sess.close() Metoda run a obiectului sess primește ca parametru un target, adică o variabilă / operație din cadrul modelului pe care să o execute sau căreia să-i determine valoarea. În cazul de față, modelul constă din doi tensori a, b ce reprezintă valori scalare constante, și o operație de adunare, rezultatul fiind reprezentat de tensorul c. Solicităm evaluarea (determinarea valorii) acestui tensor prin intermediul metodei run a sesiunii curente. O variantă mai practică a codului anterior este următoarea: a = tf.constant(2) b = tf.constant(3) result = sess.run(c) Rezultatul este același, dar se evită nevoia de a închide explicit sesiunea. Un parametru important al unui tensor este forma sa (shape). Forma reprezintă totalitatea dimensiunilor tensorului, respectiv numărul de elemente de pe fiecare dimensiune. Un tensor fără formă este un scalar. Un tensor cu forma [3] este un vector cu 3 elemente. Un tensor cu forma [2, 3] este o matrice cu 2 linii și 3 coloane. De exemplu mai jos se definește un tensor cu valori variabile, inițializate cu 0, ce reprezintă o matrice 2x3: mymat = tf.variable(tf.zeros([2, 3])) sess.run(tf.global_variables_initializer()) result = sess.run(mymat) Observăm faptul că inițializarea variabilelor trebuie invocată explicit în cadrul sesiunii. 2

3 În cadrul unui model nu se știu întotdeauna de la bun început valorile variabilelor implicate și ale tensorilor ce conțin date de intrare. De exemplu, în etapa de stabilire a structurii unei rețele neuronale nu se cunosc datele de antrenare, dar ele trebuie totuși implicate în operațiile din cadrul rețelei. În locul unui tensor a cărui valoare nu se cunoaște în faza de stabilire a modelului TF se poate folosi un placeholder, adică o variabilă ce ține locul alteia implicate în operațiile pe care le definește modelul. Altfel spus, un placeholder este o variabilă din cadrul modelului a cărei valoare se specifică abia atunci cînd se execută modelul. Reluăm primul exemplu: a = tf.placeholder(tf.int16) b = tf.placeholder(tf.int16) result = sess.run(c, feed_dict={a:2, b:3}) a și b nu se cunosc în prealabil, așadar în locul unor valori concrete se vor defini doi placeholderi. Valorile se stabilesc în faza de execuție, în cadul sesiunii. Metoda sess.run primește ca parametri variabila a cărei valoare trebuie calculată, precum și valorile placeholder-ilor prin intermediul parametrului feed_dict. Acesta este o structură de tip dictionary/map/hashmap ce asociază fiecărui placeholder o valoare concretă, de același tip și cu aceeași formă ca și cele specificate la definirea placeholderilor. Un alt exemplu, care realizează sumele a două perechi de vectori cu câte trei elemente: a = tf.placeholder(shape=[2, 3], dtype=tf.float32) b = tf.placeholder(shape=[2, 3], dtype=tf.float32) result = sess.run(c, feed_dict={ a:[[1.2, 2.3, 3.4],[2.4, 3.4, 5.6]], b:[[3.4, 3.5, 6.7],[3.5, 8.9, 4.5]]}) Forma placeholderilor se specifică explicit, iar valorile se furnizează în faza de execuție, ca în cazul anterior. În cazul în care numărul vectorilor nu se cunoaște, valoarea corespunzătoare a formei va fi None, iar în faza de execuție se pot specifica oricâți vectori: 3

4 #placeholderii pot conține oricati vectori cu 3 elemente a = tf.placeholder(shape=[none, 3], dtype=tf.float32) b = tf.placeholder(shape=[none, 3], dtype=tf.float32) result = sess.run(c, feed_dict={ a:[[1.2, 2.3, 3.4],[2.4, 3.4, 5.6]], b:[[3.4, 3.5, 6.7],[3.5, 8.9, 4.5]]}) Implementarea unei rețele neuronale simple Vom implementa o rețea neuronală cu ajutorul căreia vom clasifica o serie de plante cu diverse caracteristici biologice în trei specii (trei clase). Avem nevoie de o serie de date de antrenare (caracterictici ale plantelor și specia corespunzătoare fiecărui set de caracteristici), pe care le regăsim în fișierul iris.csv: Sepal.Length Sepal.Width Petal.Length Petal.Width Species setosa setosa setosa setosa versicolor versicolor versicolor versicolor vernica vernica vernica vernica Plantele vizate au 4 caracteristici specificate prin valori reale, și ele se pot încadra în trei specii (trei clase). Datele de antrenare sunt în număr de 150, pentru fiecare cunoscându-se valorile caracteristicilor, precum și clasa (specia) în care se încadrează. Scopul este de a construi o rețea neuronală și de a o antrena folosind datele cunoscute, în ideea de a putea identifica specia oricărei plante cu alte valori ale acelorași caracteristici. 4

5 Rețeaua pe care o vom implementa are următoarea structură: Codul care implementează, antrenează și evaluează o astfel de rețea este ilustrat mai jos. Prima dată listăm codul în întregime, apoi îl vom parcurge pas cu pas: 5

6 import os import matplotlib.pyplot as plt import numpy as np import pandas as pd os.environ['tf_cpp_min_log_level'] = '1' df = pd.read_csv('iris.csv') mydata = np.array(df.ix[:,:]) ins = mydata[:,:4] desouts = mydata[:,4] desoutsoh = np.zeros([desouts.shape[0], 3]) desoutsoh[np.where(desouts == 'setosa')] = [1, 0, 0] desoutsoh[np.where(desouts == 'versicolor')] = [0, 1, 0] desoutsoh[np.where(desouts == 'vernica')] = [0, 0, 1] desouts = desoutsoh inlayersize = 4 hiddenlayer1size = 8 outlayersize = 3 inph = tf.placeholder(tf.float32, [None, inlayersize]) desoutph = tf.placeholder(tf.float32, [None, outlayersize]) weights1 = tf.variable(tf.zeros([inlayersize, hiddenlayer1size])) biases1 = tf.variable(hiddenlayer1size, dtype=tf.float32) weights2 = tf.variable(tf.zeros([hiddenlayer1size, outlayersize])) biases2 = tf.variable(outlayersize, dtype=tf.float32) h1 = tf.nn.sigmoid(tf.add(tf.matmul(inph, weights1), biases1)) predouts = tf.nn.softmax(tf.add(tf.matmul(h1, weights2), biases2)) learnrate = 0.01 loss = tf.reduce_mean(tf.square(desoutph - predouts)) optimizer = tf.train.rmspropoptimizer(learnrate).minimize(loss) correct_prediction = tf.equal(tf.argmax(desoutph, 1), tf.argmax(predouts, 1)) accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) nrepochs = 5001 sess.run(tf.global_variables_initializer()) for i in range(nrepochs): traindata = {inph : ins, desoutph : desouts} opt,currentloss = sess.run([optimizer, loss], feed_dict = traindata) testdata = {inph : ins[:1,:], desoutph : desouts[:1,:]} if (i % 100) == 0: output = sess.run(predouts, feed_dict = testdata) eval = sess.run(accuracy, feed_dict = testdata) output = np.around(output, 3) print('epoch: ', i) print('output: ', output) print('loss: ', currentloss) print('accuracy: ', eval) print('\n') 6

7 Semnificația liniilor de cod este următoarea: os.environ['tf_cpp_min_log_level'] = '1' Se evită anumite mesaje informative listate de TF, inutile pentru scopurile noastre. df = pd.read_csv('iris.csv') mydata = np.array(df.ix[:,:]) ins = mydata[:,:4] desouts = mydata[:,4] Se citesc datele din fișierul csv. mydata este o matrice 150x5, pe fiecare linie conține valorile celor patru caracteristici și clasa corespunzătoare. ins sunt datele de intrare ( inputs), respectiv primele 4 coloane din mydata. desouts sunt clasele cărora le aparțin cele 150 de instanțe din setul de date, adică ultima coloană din mydata. Semnificația denumirii variabilei este desired outputs, valorile de ieșire dorite. desoutsoh = np.zeros([desouts.shape[0], 3]) desoutsoh[np.where(desouts == 'setosa')] = [1, 0, 0] desoutsoh[np.where(desouts == 'versicolor')] = [0, 1, 0] desoutsoh[np.where(desouts == 'vernica')] = [0, 0, 1] desouts = desoutsoh Cele trei ieșiri ale rețelei neuronale sunt valori ale unor probabilități, din intervalul [0, 1]. Dorim ca și datele de ieșire dorite (clasele identificate anterior), care inițial sunt string-uri, să fie specificate în același domeniu. Așadar, celor trei clase li se vor asocia vectorii [1, 0, 0] [0, 1, 0] [0, 0, 1], procedeu numit one-hot encoding. inlayersize = 4 hiddenlayer1size = 8 outlayersize = 3 Dimensiunile (nr de neuroni ale) celor trei straturi ale rețelei. Primul strat trebuie să aibă dimensiunea datelor de intrare (sunt 4 caracteristici), iar ultimul strat are dimensiunea corespunzătoare numărului de clase (sunt 3 clase). Stratul central (numit și strat ascuns) poate avea o dimensiune arbitrară, dar rezultatul clasificării depinde și de această dimensiune. 7

8 inph = tf.placeholder(tf.float32, [None, inlayersize]) desoutph = tf.placeholder(tf.float32, [None, outlayersize]) Placeholderii corespunzători datelor de intrare și celor dorite la ieșire. Nu se stabilește clar dimensiunea datelor de antrenare decât la execuția rețelei, de aceea prima componentă a shape-ului placeholderilor este None. weights1 = tf.variable(tf.zeros([inlayersize, hiddenlayer1size])) biases1 = tf.variable(hiddenlayer1size, dtype=tf.float32) weights2 = tf.variable(tf.zeros([hiddenlayer1size, outlayersize])) biases2 = tf.variable(outlayersize, dtype=tf.float32) Parametrii rețelei neuronale, scopul antrenării este de a determina cele mai bune valori ale acestora. Ponderile (weights) sunt figurate prin săgeți albastre în figura anterioară, unde se reprezintă structura rețelei, iar biases sunt termeni suplimentari, necesari pentru obținerea unei clasificări corecte. Primul set de ponderi formează o matrice 4x8 (sunt ponderile dintre primele două straturi), iar biases1 sunt în număr de 8 (corespund neuronilor din stratul ascuns). În mod similar, al doilea set de ponderi este în număr de 8x3 (ponderile dintre stratul ascuns și cel de ieșire), iar biases2 sunt în număr de 3, câte o valoare pentru fiecare neuron din stratul de ieșire. h1 = tf.nn.sigmoid(tf.add(tf.matmul(inph, weights1), biases1)) predouts = tf.nn.softmax(tf.add(tf.matmul(h1, weights2), biases2)) Operațiile care se realizează în cadrul rețelei neuronale (vezi documentația aferentă pentru detalii). Se obțin valorile prezise (predouts) ce reprezintă probabilitățile de încadrare în fiecare din cele trei clase. În faza de antrenare, acestea se vor compara cu cele cunoscute (cele dorite) și astfel se va determina o eroare utilă la actualizarea valorilor ponderilor. learnrate = 0.01 Rata de învățare. În fiecare etapă de antrenare, ponderile se ajustează cu valori controlabile prin setarea acestui parametru. loss = tf.reduce_mean(tf.square(desoutph - predouts)) Eroarea de clasificare - se evaluează diferența dintre valorile de ieșire generate de rețea (predouts) și cele dorite (datele furnizate prin intermediul placeholderului desoutph). În cazul de față se folosește MSE (Mean Squared Error, eroarea pătratică medie) dar există și alte formule de calcul al acestei erori. 8

9 optimizer = tf.train.rmspropoptimizer(learnrate).minimize(loss) Antrenarea rețelei neuronale. Scopul este de a determina valorile optimale ale parametrilor rețelei, cele pentru care eroarea calculată anterior este minimă. În acest scop se folosește un optimizer, o metodă de optimizare deja implementată. correct_prediction = tf.equal(tf.argmax(desoutph, 1), tf.argmax(predouts, 1)) accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) Se evaluează acuratețea predicției rețelei, i.e. câte dintre datele de test au fost clasificate corect. nrepochs = 5001 Numărul de epoci, i.e. de câte ori vor fi supuse datele inițiale procesului de antrenare. Stabilirea sesiunii, din acest moment se execută efectiv operațiile definite anterior. for i in range(nrepochs): Pentru fiecare epocă traindata = {inph : ins, desoutph : desouts} Se stabilesc valorile concrete ale datelor de antrenare definite prin cei doi placeholderi declarați anterior. opt,currentloss = sess.run([optimizer, loss], feed_dict = traindata) Se execută procesul de antrenare a rețelei folosind datele de antrenare, rezultă eroarea de clasificare currentloss testdata = {inph : ins[:1,:], desoutph : desouts[:1,:]} Datele de test, în cazul de față prima instanță din setul de date de antrenare. 9

10 if (i % 100) == 0: output = sess.run(predouts, feed_dict = testdata) eval = sess.run(accuracy, feed_dict = testdata) output = np.around(output, 3) print('epoch: ', i) print('output: ', output) print('loss: ', currentloss) print('accuracy: ', eval) print('\n') La fiecare 100 de epoci, se afisează o parte din datele calculate anterior. Aplicații: 1. Modificați parametrii rețelei în ideea de a obține o eroare cât mai mică și o acuratețe cât mai mare, pentru date de test ce rezultă din diverse combinații ale datelor de antrenare. Parametrii care se pot modifica sunt: - Numărul de neuroni din stratul ascuns - Numărul de straturi ascunse - Valoarea ratei de învățare - Metoda de optimizare (se poate alege una din metodele din documentație) - Metoda de calcul al erorii (ca alternativă, se poate folosi formula cross entropy, vezi documentația pentru detalii) Obs: Pentru o antrenare mai corectă statistic, datele de antrenare de obicei se amestecă în măsură cât mai mare (în Python se poate folosi np.random.shuffle) 2. Antrenați rețeaua proiectată anterior folosind doar o parte din datele disponibile inițial, iar pentru test utilizați-le pe celelalte; comparați diferența cu cazul precedent (când toate datele disponibile se folosesc pentru antrenare). 3. Antrenați rețeaua folosind o abordare de tip bootstrap. Principiul este similar cu cel din cadrul algoritmului Random Forest. În loc să se folosească pentru antrenare întregul set de date, se formează grupuri selectate aleator din setul de date inițial și se antrenează rețeaua cu fiecare grup. Grupurile vor fi mai mici decât dimensiunea setului de date inițial, dar numărul grupurilor poate fi considerabil. Comparați rezultatul antrenării cu cel obținut anterior. 10