Python Tensorflow apmācība

Šajā nodarbībā aplūkosim TensorFlow, kas ir atvērtā koda mašīnmācīšanās bibliotēka, ko izmanto, lai izstrādātu, veidotu un apmācītu dziļu mācību modeļus. Ir iespējams veikt skaitliskus aprēķinus ar TensorFlow bibliotēku, kuras datu plūsmas diagrammas, kurās matemātiskās darbības tiek attēlotas kā mezgli un dati tiek attēlotas kā malas starp šiem mezgliem.

Šajā nodarbībā mēs apskatīsim trīs galvenās tēmas:

Kas ir Tensors un TensorFlow
ML algoritmu lietošana ar TensorFlow
TensorFlow lietošanas gadījumi

TensorFlow ir lieliska Google Python pakete, kas labi izmanto datu plūsmas programmēšanas paradigmu ļoti optimizētām matemātiskām aprēķiniem. Dažas no TensorFlow funkcijām ir:

Izplatīta skaitļošanas iespēja, kas atvieglo datu pārvaldību lielos komplektos
Dziļa mācīšanās un neironu tīkla atbalsts ir labs
Tas ļoti efektīvi pārvalda sarežģītas matemātiskas struktūras, piemēram, n-dimensiju masīvus

Pateicoties visām šīm funkcijām un mašīnmācīšanās algoritmu klāstam, TensorFlow ievieš to kā ražošanas apjoma bibliotēku. Iegremdēsimies TensorFlow jēdzienos, lai uzreiz pēc tam mēs varētu sasmērēt rokas ar kodu.

TensorFlow instalēšana

Tā kā TensorFlow izmantosim Python API, ir labi zināt, ka tas darbojas gan ar Python 2.7 un 3.3+ versijas. Instalēsim TensorFlow bibliotēku, pirms pārejam pie faktiskajiem piemēriem un koncepcijām. Ir divi veidi, kā instalēt šo pakotni. Pirmais ietver Python pakotņu pārvaldnieka, pip izmantošanu:

pip instalēt tensorflow

Otrais veids attiecas uz Anaconda, mēs varam instalēt pakotni kā:

conda install -c conda-forge tensorflow

Nekautrējieties meklēt nakts versijas un GPU versijas oficiālajās TensorFlow instalācijas lapās.

Es izmantošu Anaconda vadītāju visiem šīs nodarbības piemēriem. Es palaidīšu Jupyter piezīmju grāmatiņu tam pašam:

Tagad, kad mēs esam gatavi ar visiem importēšanas paziņojumiem uzrakstīt kodu, sāksim ienirt SciPy paketē ar dažiem praktiskiem piemēriem.

Kas ir Tensors?

Tensori ir Tensorflow izmantotās datu pamatstruktūras. Jā, tie ir tikai veids, kā attēlot datus dziļās mācībās. Vizualizēsim tos šeit:

Kā aprakstīts attēlā, tenzorus var saukt par n-dimensiju masīvu kas ļauj mums attēlot datus sarežģītās dimensijās. Mēs varam domāt par katru dimensiju kā par atšķirīgu datu pazīmi dziļās mācībās. Tas nozīmē, ka Tensors var kļūt diezgan sarežģīts, ja runa ir par sarežģītām datu kopām ar daudzām funkcijām.

Kad mēs zinām, kas ir Tensors, es domāju, ka ir diezgan viegli iegūt to, kas notiek TensorFlow. Šie termini nozīmē, kā tenori vai funkcijas var plūst datu kopās, lai iegūtu vērtīgu produkciju, kad mēs ar to veicam dažādas darbības.

Izpratne par TensorFlow ar konstantēm

Tāpat kā mēs lasījām iepriekš, TensorFlow ļauj mums veikt mašīnmācīšanās algoritmus Tensors, lai iegūtu vērtīgu rezultātu. Izmantojot TensorFlow, Deep Learning modeļu izstrāde un apmācība ir tieša.

TensorFlow nāk ar ēku Aprēķinu grafiki. Aprēķinu grafiki ir datu plūsmas grafiki, kuros matemātiskās darbības tiek attēlotas kā mezgli un dati tiek attēlotas kā malas starp šiem mezgliem. Uzrakstīsim ļoti vienkāršu koda fragmentu, lai sniegtu konkrētu vizualizāciju:

importēt tensorflow kā tf
x = tf.nemainīgs (5)
y = tf.nemainīgs (6)
z = x * y
drukāt (z)

Izpildot šo piemēru, mēs redzēsim šādu izvadi:

Kāpēc reizināšana ir nepareiza? Tas nebija tas, ko mēs gaidījām. Tas notika tāpēc, ka šādi mēs nevaram veikt darbības ar TensorFlow. Pirmkārt, mums jāsāk a sesija lai aprēķinu grafiks darbotos,

Izmantojot Session, mēs varam iekapsulēt Tensoru darbības un stāvokļa kontrole. Tas nozīmē, ka sesija var arī saglabāt skaitļošanas grafika rezultātu, lai tā varētu nodot šo rezultātu nākamajai operācijai cauruļvadu izpildes secībā. Tagad izveidosim sesiju, lai iegūtu pareizu rezultātu:

# Sāciet ar sesijas objektu
sesija = tf.Sesija ()
# Sniedziet aprēķinu sesijai un saglabājiet to
rezultāts = sesija.palaist (z)
# Izdrukājiet aprēķina rezultātu
izdrukāt (rezultāts)
# Aizvērt sesiju
sesija.aizvērt ()

Šoreiz mēs ieguvām sesiju un nodrošinājām to ar aprēķinu, kas nepieciešams, lai palaistu mezglos. Izpildot šo piemēru, mēs redzēsim šādu izvadi:

Lai gan mēs saņēmām brīdinājumu no TensorFlow, mēs tomēr saņēmām pareizo rezultātu no aprēķina.

Viena elementa tenzora darbības

Tāpat kā pēdējā piemērā mēs reizinājām divus nemainīgus tenorus, arī TensorFlow mums ir daudzas citas darbības, kuras var veikt ar atsevišķiem elementiem:

pievienot
atņemt
vairoties
div
mod
abs
negatīvs
zīmi
kvadrāts
raunds
kvrt
Pow
exp
žurnāls
maksimāli
minimums
cos
grēks

Viena elementa darbības nozīmē, ka pat tad, ja jūs sniedzat masīvu, darbības tiks veiktas ar katru šī masīva elementu. Piemēram:

importēt tensorflow kā tf
importēt numpy kā np
tenors = np.masīvs ([2, 5, 8])
tenzors = tf.convert_to_tensor (tenzors, dtype = tf.pludiņš64)
ar tf.Sesija () kā sesija:
drukāt (sesija.palaist (tf.cos (tenzors)))

Izpildot šo piemēru, mēs redzēsim šādu izvadi:

Mēs šeit sapratām divus svarīgus jēdzienus:

Jebkuru NumPy masīvu var viegli pārveidot par Tensor, izmantojot funkciju convert_to_tensor
Operācija tika veikta katram NumPy masīva elementam

Vietnieki un mainīgie

Vienā no iepriekšējām sadaļām mēs apskatījām, kā mēs varam izmantot Tensorflow konstantes, lai izveidotu skaitļošanas grafikus. Bet TensorFlow ļauj mums arī ņemt vērā ievadus, lai aprēķināšanas grafiks pēc būtības būtu dinamisks. Tas ir iespējams ar Vietnieku un Mainīgo palīdzību.

Faktiski vietturi nesatur nekādus datus, un izpildes laikā tie ir jāiesniedz derīgi un, kā paredzēts, bez ievades tie radīs kļūdu.

Vietnieku var apzīmēt kā vienošanos diagrammā, ka ievade noteikti tiks sniegta izpildlaikā. Šis ir vietturu piemērs:

importēt tensorflow kā tf
# Divi vietturi
x = tf. vietturis (tf.pludiņš32)
y = tf. vietturis (tf.pludiņš32)
# Piešķirt reizināšanas operāciju w.r.t. a & b uz mezglu mul
z = x * y
# Izveidojiet sesiju
sesija = tf.Sesija ()
# Ievietojiet vietu izvietotāju vērtības
rezultāts = sesija.palaist (z, x: [2, 5], y: [3, 7])
drukāt ('reizinot x un y:', rezultāts)

Izpildot šo piemēru, mēs redzēsim šādu izvadi:

Tagad, kad mums ir zināšanas par vietturiem, pievērsīsim uzmanību mainīgajiem. Mēs zinām, ka vienādojuma rezultāts laika gaitā var mainīties vienam un tam pašam ievadu kopumam. Tātad, apmācot mūsu modeļa mainīgo, tas laika gaitā var mainīt savu uzvedību. Šajā scenārijā mainīgais ļauj mums pievienot šos apmācāmos parametrus mūsu skaitļošanas grafikam. Mainīgo var definēt šādi:

x = tf.Mainīgais ([5.2], dtype = tf.pludiņš32)

Iepriekš minētajā vienādojumā x ir mainīgais, kas norāda tā sākotnējo vērtību un datu tipu. Ja mēs nenorādīsim datu tipu, to TensorFlow secinās ar tā sākotnējo vērtību. Šeit skatiet TensorFlow datu tipus.

Atšķirībā no konstantes, mums ir jāizsauc Python funkcija, lai inicializētu visus grafika mainīgos:

init = tf.global_variables_initializer ()
sesija.palaist (init)

Pirms mēs izmantojam mūsu diagrammu, noteikti palaidiet iepriekš minēto TensorFlow funkciju.

Lineārā regresija ar TensorFlow

Lineārā regresija ir viens no visbiežāk izmantotajiem algoritmiem, ko izmanto, lai izveidotu sakarību dotajos nepārtrauktajos datos. Šīs attiecības starp koordinātu punktiem, teiksim, x un y, sauc par a hipotēze. Kad mēs runājam par lineāro regresiju, hipotēze ir taisna:

y = mx + c

Šeit m ir līnijas slīpums, un šeit tas ir vektors, kas attēlo svari. c ir nemainīgais koeficients (y-pārtvertais), un šeit tas ir Aizspriedums. Svaru un novirzi sauc par modeļa parametriem.

Lineārās regresijas ļauj mums novērtēt svara un novirzes vērtības tā, lai mums būtu minimums izmaksu funkcija. Visbeidzot, x ir neatkarīgais mainīgais vienādojumā un y ir atkarīgs mainīgais. Tagad sāksim veidot lineāro modeli TensorFlow ar vienkāršu koda fragmentu, kuru mēs izskaidrosim:

importēt tensorflow kā tf
# Parametru slīpuma (W) mainīgie ar sākotnējo vērtību 1.1
W = tf.Mainīgais ([1.1], tf.pludiņš32)
# Mainīgs aizspriedumiem (b) ar sākotnējo vērtību -1.1
b = tf.Mainīgais ([- 1.1], tf.pludiņš32)
# Vietnieki ievades vai neatkarīga mainīgā nodrošināšanai, apzīmēti ar x
x = tf.vietturis (tf.pludiņš32)
# Līnijas vai lineārās regresijas vienādojums
lineārs_modelis = W * x + b
# Visu mainīgo inicializēšana
sesija = tf.Sesija ()
init = tf.global_variables_initializer ()
sesija.palaist (init)
# Izpildīt regresijas modeli
drukāt (sesija.palaist (lineārs_modelis x: [2, 5, 7, 9]))

Šeit mēs izdarījām tikai to, ko mēs iepriekš paskaidrojām, šeit apkoposim:

Mēs sākām ar TensorFlow importēšanu mūsu skriptā
Izveidojiet dažus mainīgos, kas atspoguļo vektora svaru un parametru novirzi
Lai attēlotu ievadi, būs vajadzīgs vietturis x
Pārstāv lineāro modeli
Inicializējiet visas modelim nepieciešamās vērtības

Izpildot šo piemēru, mēs redzēsim šādu izvadi:

Vienkāršais koda fragments tikai sniedz pamatideju par to, kā mēs varam izveidot regresijas modeli. Bet mums joprojām ir jāveic vēl dažas darbības, lai pabeigtu izveidoto modeli:

Mums ir jāpadara mūsu modelis pašmācāms, lai tas varētu radīt izvadi jebkurai ievadītajai ieejai
Mums ir jāapstiprina modeļa sniegtā izeja, salīdzinot to ar paredzamo izvadi dotajam x

Zaudējumu funkcija un modeļa apstiprināšana

Lai apstiprinātu modeli, mums ir jābūt pasākumam, kā pašreizējās izejas novirze ir no paredzamās izejas. Apstiprināšanai šeit var izmantot dažādas zaudējumu funkcijas, taču mēs aplūkosim vienu no visizplatītākajām metodēm, Kvadrātu kļūdas jeb SSE summa.

SSE vienādojums ir šāds:

E = 1/2 * (t - y) 2

Šeit:

E = vidējā kvadrāta kļūda
t = Saņemtā izeja
y = paredzamā izlaide
t - y = kļūda

Tagad ierakstīsim koda fragmentu turpinājumā pēdējam fragmentam, lai atspoguļotu zaudējuma vērtību:

y = tf.vietturis (tf.pludiņš32)
kļūda = lineārs_modelis - y
kvadrātā_kļūdas = tf.kvadrāts (kļūda)
zaudējumi = tf.samazināt_summu (kvadrātā_kļūdas)
drukāt (sesija.palaist (zaudējums, x: [2, 5, 7, 9], y: [2, 4, 6, 8]))

Izpildot šo piemēru, mēs redzēsim šādu izvadi:

Skaidrs, ka zaudētā vērtība ir ļoti zema dotajam lineārās regresijas modelim.

Secinājums

Šajā nodarbībā mēs apskatījām vienu no populārākajām padziļinātas apmācības un mašīnmācīšanās paketēm TensorFlow. Mēs arī izveidojām lineāru regresijas modeli, kam bija ļoti augsta precizitāte.