TensorFlow Tutorial - Deep Learning Brug af TensorFlow

TensorFlow tutorial er den tredje blog i serien. Det inkluderer alle de grundlæggende i TensorFlow. Det taler også om, hvordan man opretter en simpel lineær model.

Jeg har designet denne TensorFlow-tutorial til fagfolk og entusiaster, der er interesserede i at anvende Deep Learning Algorithm ved hjælp af TensorFlow til at løse forskellige problemer. TensorFlow er et open source dyb læringsbibliotek, der er baseret på konceptet med dataflytningsgrafer til bygning af modeller. Det giver dig mulighed for at oprette store neurale netværk med mange lag.At lære at bruge dette bibliotek er også en grundlæggende del af biblioteket .Følgende er de emner, der vil blive diskuteret i denne TensorFlow tutorial blog:



  • Hvad er TensorFlow
  • Grundlæggende om TensorFlow-kode
  • TensorFlow UseCase

Hvad er tensorer?

Før vi taler om TensorFlow, skal vi først forstå i denne TensorFlow-selvstudie hvad er tensorer . Tensorer er intet andet end en de facto til at repræsentere dataene i dyb læring.



Tensorer - TensorFlow tutorial - EdurekaSom vist på billedet ovenfor er tensorer bare flerdimensionelle arrays, der giver dig mulighed for at repræsentere data med højere dimensioner. Generelt beskæftiger Deep Learning dig med højdimensionale datasæt, hvor dimensioner refererer til forskellige funktioner, der findes i datasættet. Navnet “TensorFlow” er faktisk afledt af de operationer, som neurale netværk udfører på tensorer. Det er bogstaveligt talt en strøm af tensorer. Siden har du forstået, hvad der er tensorer, lad os gå videre i denne TensorFlow-tutorial og forstå - hvad er TensorFlow?

Hvad er TensorFlow?

TensorFlow er et bibliotek baseret på Python, der giver forskellige typer funktionalitet til implementering af Deep Learning Models. Som diskuteret tidligere består udtrykket TensorFlow af to termer - Tensor & Flow:



I TensorFlow henviser udtrykket tensor til repræsentation af data som multidimensionelt array, hvorimod udtrykket flow henviser til den række af operationer, som man udfører på tensorer som vist i ovenstående billede.

Nu har vi dækket nok baggrund om TensorFlow.



Derefter diskuterer vi i denne TensorFlow-tutorial om TensorFlow-kodebasics.

TensorFlow Tutorial: Grundlæggende om kode

Grundlæggende involverer den overordnede proces med at skrive et TensorFlow-program to trin:

  1. Opbygning af en beregningsgraf
  2. Kørsel af en beregningsgraf

Lad mig forklare dig ovenstående to trin en efter en:

1. Opbygning af en beregningsgraf

Så, hvad er en beregningsgraf? Nå, en beregningsgraf er en række TensorFlow-operationer arrangeret som noder i grafen. Hver knude tager 0 eller flere tensorer som input og producerer en tensor som output. Lad mig give dig et eksempel på en simpel beregningsgraf, der består af tre noder - til , b & c som vist nedenfor:

Forklaring til ovenstående beregningsgraf:

  • Konstant knudepunkterbruges til at gemme konstante værdier, da det tager nul input, men producerer de lagrede værdier som output. I ovenstående eksempel er a og b konstante noder med henholdsvis værdierne 5 og 6.

  • Knudepunktet c repræsenterer operationen med at multiplicere konstant knudepunkt a med b. Derfor vil eksekvering af node c resultere i multiplikation af const node a & b.

Dybest set kan man tænke på en beregningsgraf som en alternativ måde at konceptualisere matematiske beregninger, der finder sted i et TensorFlow-program. De operationer, der er tildelt forskellige noder i en beregningsgraf, kan udføres parallelt og giver således en bedre ydelse med hensyn til beregninger.

Her beskriver vi bare beregningen, den beregner ikke noget, den indeholder ingen værdier, den definerer bare de operationer, der er angivet i din kode.

2. Kørsel af en beregningsgraf

Lad os tage det forrige eksempel på beregningsgraf og forstå, hvordan vi udfører det. Følgende er koden fra forrige eksempel:

hvad gør trim i java

Eksempel 1:

importer tensorflow som tf # Byg en graf a = tf.constant (5.0) b = tf.constant (6.0) c = a * b

For at få output fra node c er vi nu nødt til at køre beregningsgrafen inden for a session . Session placerer grafhandlingerne på enheder, såsom CPU'er eller GPU'er, og giver metoder til at udføre dem.

En session indkapsler styringen og tilstanden af ​​TensorFlow-runtime, dvs. den gemmer informationen om den rækkefølge, som alle operationer skal udføres i, og sender resultatet af allerede beregnet operation til den næste operation i rørledningen. Lad mig vise dig, hvordan du kører ovenstående beregningsgraf inden for en session (Forklaring på hver linje kode er tilføjet som en kommentar):

# Opret sessionsobjektet sess = tf.Session () # Kør grafen inden for en session, og gem output til en variabel output_c = sess.run (c) # Udskriv output for node c print (output_c) # Luk sessionen til frigør nogle ressourcer sess.close ()
 Produktion: 30

Så alt handlede om session og kørsel af en beregningsgraf indeni den. Lad os nu tale om variabler og pladsholdere, som vi vil bruge i vid udstrækning, mens vi bygger dyb læringsmodel ved hjælp af TensorFlow.

Konstanter, pladsholder og variabler

I TensorFlow bruges konstanter, pladsholdere og variabler til at repræsentere forskellige parametre i en dyb læringsmodel. Da jeg allerede har diskuteret konstanter tidligere, vil jeg starte med pladsholdere.

Pladsholder:

En TensorFlow-konstant giver dig mulighed for at gemme en værdi, men hvad hvis du vil have dine noder til at tage input på farten? Til denne form for funktionalitet bruges pladsholdere, som gør det muligt for din graf at tage eksterne input som parametre. Dybest set er en pladsholder et løfte om at give en værdi senere eller i løbetid. Lad mig give dig et eksempel for at gøre tingene enklere:

importer tensorflow som tf # Oprettelse af pladsholdere a = tf. pladsholder (tf.float32) b = tf. pladsholder (tf.float32) # Tildeling af multiplikationshandling w.r.t. a & ampamp b til knudepunkt mul mul = a * b # Opret session objekt sess = tf.Session () # Udfør mul ved at overføre værdierne [1, 3] [2, 4] for henholdsvis a og b output = sess.run ( mul, {a: [1,3], b: [2, 4]}) print ('Multiplikation ab:', output)
 Produktion: [2. 12.]

Punkter at huske på pladsholdere:

  • Pladsholdere initialiseres ikke og indeholder ingen data.
  • Man skal levere input eller feeds til pladsholderen, der tages i betragtning under løbetiden.
  • At udføre en pladsholder uden input genererer en fejl.

Lad os gå videre og forstå - hvad er variabler?

Variabler

I dyb læring bruges pladsholdere til at tage vilkårlige input i din model eller graf. Udover at tage input, skal du også ændre grafen, så den kan producere nye output w.r.t. samme indgange. Til dette vil du bruge variabler. I en nøddeskal giver en variabel dig mulighed for at tilføje sådanne parametre eller knudepunkter til grafen, der kan trænes, dvs. værdien kan ændres over en periode. Variabler defineres ved at angive deres indledende værdi og type som vist nedenfor:

var = tf. variabel ([0.4], dtype = tf.float32)

Bemærk:

  • Hvis du ikke har angivet datatypen eksplicit, udleder TensorFlow typen af ​​konstanten / variablen fra den initialiserede værdi.
  • TensorFlow har mange af sine egne datatyper som tf.float32 , tf.int32 etc. Du kan henvise til dem alle over her .

Konstanter initialiseres, når du ringer tf. konstant , og deres værdi kan aldrig ændre sig. Tværtimod initialiseres ikke variabler, når du ringer tf. variabel . For at initialisere alle variablerne i et TensorFlow-program skal du skal udtrykkeligt kalde en speciel operation som vist nedenfor:

init = tf.global_variables_initializer () sess.run (init)

Husk altid, at en variabel skal initialiseres, før en graf bruges for første gang.

Bemærk: TensorFlow-variabler er hukommelsesbuffere, der indeholder tensorer, men i modsætning til normale tensorer, der kun instantieres, når en graf køres og straks slettes bagefter, overlever variabler på tværs af flere udførelser af en graf.

Nu hvor vi har dækket nok af det grundlæggende i TensorFlow, lad os gå videre og forstå, hvordan vi implementerer en lineær regressionsmodel ved hjælp af TensorFlow.

Lineær regressionsmodel ved hjælp af TensorFlow

Lineær regressionsmodel bruges til at forudsige den ukendte værdi af en variabel (afhængig variabel) fra den kendte værdi af en anden variabel (uafhængig variabel) ved hjælp af lineær regressionsligning som vist nedenfor:

Derfor har du brug for at oprette en lineær model:

  1. Afhængig eller outputvariabel (Y)
  2. Hældningsvariabel (w)
  3. Y - Aflytning eller forspænding (b)
  4. Uafhængig eller inputvariabel (X)

Så lad os begynde at opbygge lineær model ved hjælp af TensorFlow:

Kopier koden ved at klikke på knappen nedenfor:

# Oprettelse af variabel til parameterhældning (W) med startværdi som 0,4 W = tf.Variabel ([. 4], tf.float32) # Oprettelse af variabel til parameterbias (b) med initialværdi som -0,4 b = tf.Variabel ( [-0.4], tf.float32) # Oprettelse af pladsholdere til levering af input eller uafhængig variabel, betegnet med xx = tf.placeholder (tf.float32) # Ligning af lineær regression linear_model = W * x + b # Initialisering af alle variablerneessess = tf.Session () init = tf.global_variables_initializer () sess.run (init) # Kører regressionsmodel for at beregne output wrt til forudsat x-værdi udskrives (sess.run (linear_model {x: [1, 2, 3, 4]}))

Produktion:

[0. 0.40000001 0.80000007 1.20000005]

Ovennævnte kode repræsenterer bare den grundlæggende idé bag implementeringen af ​​regressionsmodel, dvs. hvordan du følger ligningen af ​​regressionslinien for at få output w.r.t. et sæt inputværdier. Men der er to ting tilbage, der skal tilføjes i denne model for at gøre det til en komplet regressionsmodel:

  • For det første er vi nødt til at tilvejebringe en mekanisme, hvormed vores model kan træne sig selv automatisk baseret på givne sæt input og respektive output.
  • Den anden ting, vi har brug for, er at validere vores uddannede model ved at sammenligne dens output med det ønskede output eller måloutput baseret på et givet sæt x-værdier.

Lad os nu forstå, hvordan jeg kan inkorporere de ovennævnte funktionaliteter i min kode til regressionsmodel.

Tabsfunktion - Modelvalidering

En tabsfunktion måler, hvor langt den aktuelle output fra modellen er fra den ønskede eller den ønskede output. Jeg bruger en mest anvendte tabsfunktion til min lineære regressionsmodel kaldet Sum of Squared Error eller SSE. SSE beregnet w.r.t. modeloutput (repræsenteret ved linear_model) og ønsket output eller måloutput (y) som:

y = tf.placeholder (tf.float32) fejl = linear_model - y squared_errors = tf.square (error) tab = tf.reduce_sum (squared_errors) print (sess.run (tab, {x: [1,2,3,4) ], y: [2, 4, 6, 8]})
 Produktion: 90,24

Som du kan se, får vi en høj tabsværdi. Derfor er vi nødt til at justere vores vægte (W) og bias (b) for at reducere den fejl, vi modtager.

tf.train API - Uddannelse af modellen

TensorFlow leverer optimeringsmidler der langsomt ændrer hver variabel for at minimere tabsfunktionen eller -fejlen. Den enkleste optimering er gradient nedstigning . Den ændrer hver variabel i henhold til størrelsen af ​​det afledte tab i forhold til den variabel.

# Oprettelse af en forekomst af gradientnedstigningsoptimeringsoptimizer = tf.train.GradientDescentOptimizer (0.01) tog = optimizer.minimerer (tab) for jeg inden for rækkevidde (1000): sess.run (tog, {x: [1, 2, 3, 4], y: [2, 4, 6, 8]}) print (sess.run ([W, b]))
 Produktion: [array ([1.99999964], dtype = float32), array ([9.86305167e-07], dtype = float32)]

Så det er sådan, du opretter en lineær model ved hjælp af TensorFlow og træner den for at få det ønskede output.

Nu hvor du kender til dyb læring, skal du tjekke af Edureka, et pålideligt online læringsfirma med et netværk på mere end 250.000 tilfredse elever spredt over hele kloden. Edureka Deep Learning with TensorFlow-certificeringskursus hjælper eleverne med at blive ekspert i træning og optimering af grundlæggende og konvolutionelle neurale netværk ved hjælp af realtidsprojekter og opgaver sammen med koncepter som SoftMax-funktion, Auto-encoder Neural Networks, Restricted Boltzmann Machine (RBM).

Har du et spørgsmål til os? Nævn det i kommentarfeltet, så vender vi tilbage til dig.