TensorFlow-handledning - Djup inlärning med TensorFlow

TensorFlow-handledning är den tredje bloggen i serien. Den innehåller alla grunderna i TensorFlow. Det talar också om hur man skapar en enkel linjär modell.

Jag har utformat denna TensorFlow-handledning för proffs och entusiaster som är intresserade av att tillämpa Deep Learning Algorithm med TensorFlow för att lösa olika problem. TensorFlow är ett djupt inlärningsbibliotek med öppen källkod som bygger på begreppet dataflödesdiagram för att bygga modeller. Det låter dig skapa storskaliga neurala nätverk med många lager.Att lära sig att använda detta bibliotek är också en grundläggande del av biblioteket .Följande är de ämnen som kommer att diskuteras i den här TensorFlow-handledningsbloggen:

  • Vad är TensorFlow
  • Grundläggande om TensorFlow-kod
  • TensorFlow UseCase

Vad är Tensorer?

I den här TensorFlow-självstudien, innan vi pratar om TensorFlow, låt oss först förstå vad är tensorer . Tensorer är inget annat än en de facto för att representera data i djupinlärning.



Tensorer - TensorFlow-handledning - EdurekaSom visas i bilden ovan är tensorer bara flerdimensionella matriser som gör att du kan representera data med högre dimensioner. I allmänhet hanterar du Deep Learning dig med högdimensionella datamängder där dimensioner hänvisar till olika funktioner som finns i datamängden. I själva verket har namnet 'TensorFlow' härrör från de operationer som neurala nätverk utför på tensorer. Det är bokstavligen ett flöde av tensorer. Sedan har du förstått vad som är tensorer, låt oss gå vidare i denna TensorFlow-handledning och förstå - vad är TensorFlow?

Vad är TensorFlow?

TensorFlow är ett bibliotek baserat på Python som tillhandahåller olika typer av funktioner för implementering av Deep Learning Models. Som diskuterats tidigare består termen TensorFlow av två termer - Tensor & Flow:

I TensorFlow hänvisar termen tensor till representationen av data som flerdimensionell array medan termen flow hänvisar till den serie av operationer som man utför på tensorer som visas i bilden ovan.

Nu har vi täckt tillräckligt med bakgrund om TensorFlow.

Därefter kommer vi i denna TensorFlow-handledning att diskutera om TensorFlow-kodgrunderna.

TensorFlow-handledning: Grundläggande kod

I grund och botten innefattar den övergripande processen att skriva ett TensorFlow-program två steg:

  1. Bygga en beräkningsgraf
  2. Köra en beräkningsgraf

Låt mig förklara ovanstående två steg en efter en:

1. Bygga en beräkningsgraf

Så, vad är ett beräkningsdiagram? En beräkningsgraf är en serie TensorFlow-operationer ordnade som noder i diagrammet. Varje noder tar 0 eller fler tensorer som ingång och producerar en tensor som utgång. Låt mig ge dig ett exempel på en enkel beräkningsgraf som består av tre noder - till , b & c enligt nedanstående:

Förklaring till ovanstående beräkningsdiagram:

  • Konstanta noderanvänds för att lagra konstanta värden eftersom det tar ingen ingång, men producerar de lagrade värdena som utdata. I exemplet ovan är a och b konstanta noder med värdena 5 respektive 6.

  • Noden c representerar operationen för att multiplicera konstant nod a med b. Därför kommer körning av nod c att resultera i multiplikation av konstnod a & b.

I grund och botten kan man tänka på ett beräkningsdiagram som ett alternativt sätt att konceptualisera matematiska beräkningar som sker i ett TensorFlow-program. De operationer som tilldelats olika noder i en beräkningsgraf kan utföras parallellt, vilket ger en bättre prestanda när det gäller beräkningar.

Här beskriver vi bara beräkningen, den beräknar ingenting, den innehåller inga värden, den definierar bara de funktioner som anges i din kod.

androidstudiohandledning för nybörjare

2. Köra en beräkningsgraf

Låt oss ta det tidigare exemplet på beräkningsgraf och förstå hur vi kör det. Följande är koden från föregående exempel:

Exempel 1:

importera tensorflöde som tf # Skapa ett diagram a = tf.constant (5.0) b = tf.constant (6.0) c = a * b

För att få utdata från nod c måste vi köra beräkningsdiagrammet inom a session . Session placerar grafoperationerna på enheter, till exempel CPU: er eller GPU: er, och tillhandahåller metoder för att utföra dem.

En session inkapslar kontrollen och tillståndet för TensorFlow-körtiden, dvs. den lagrar informationen om den ordning i vilken alla operationer kommer att utföras och skickar resultatet av redan beräknad operation till nästa operation i rörledningen. Låt mig visa dig hur du kör ovanstående beräkningsdiagram inom en session (Förklaring av varje kodrad har lagts till som en kommentar):

# Skapa sessionsobjektet sess = tf.Session () # Kör grafen i en session och lagra utdata till en variabel output_c = sess.run (c) # Skriv ut utgången från nod c print (output_c) # Stäng sessionen till frigöra några resurser sess.close ()
 Produktion: 30

Så det handlade om session och kör en beräkningsgraf inom den. Låt oss nu prata om variabler och platshållare som vi kommer att använda i stor utsträckning när vi bygger en djup inlärningsmodell med TensorFlow.

Konstanter, platshållare och variabler

I TensorFlow används konstanter, platshållare och variabler för att representera olika parametrar i en djup inlärningsmodell. Eftersom jag redan har diskuterat konstanter tidigare kommer jag att börja med platshållare.

Platshållare:

En TensorFlow-konstant låter dig lagra ett värde, men tänk om du vill att dina noder ska ta ingångar på språng? För denna typ av funktionalitet används platshållare som gör att din graf kan ta externa ingångar som parametrar. I grund och botten är en platshållare ett löfte om att ge ett värde senare eller under körning. Låt mig ge dig ett exempel för att göra saker enklare:

importera tensorflöde som tf # Skapa platshållare a = tf. platshållare (tf.float32) b = tf. platshållare (tf.float32) # Tilldela multiplikationsåtgärd w.r.t. a & ampamp b till nod mul mul = a * b # Skapa sessionsobjekt sess = tf.Session () # Exekvera mul genom att skicka värdena [1, 3] [2, 4] för a respektive b output = sess.run ( mul, {a: [1,3], b: [2, 4]}) tryck ('Multiplicera ab:', utdata)
 Produktion: [2. 12.]

Poäng att komma ihåg om platshållare:

  • Platshållare initialiseras inte och innehåller ingen data.
  • Man måste tillhandahålla ingångar eller flöden till platshållaren som beaktas under körning.
  • Att köra en platshållare utan inmatning genererar ett fel.

Låt oss nu gå vidare och förstå - vad är variabler?

java konvertera dubbel till heltal

Variabler

I djupinlärning används platshållare för att ta godtyckliga ingångar i din modell eller graf. Förutom att ta inmatning måste du också ändra grafen så att den kan producera nya utgångar w.r.t. samma ingångar. För detta kommer du att använda variabler. I ett nötskal tillåter en variabel dig att lägga till sådana parametrar eller noder i diagrammet som kan tränas, dvs. värdet kan ändras över en tidsperiod. Variabler definieras genom att ange deras ursprungliga värde och typ enligt nedan:

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

Notera:

  • Om du inte har angett datatypen uttryckligen kommer TensorFlow att dra slutsatsen om typen av konstant / variabel från det initialiserade värdet.
  • TensorFlow har många av sina egna datatyper som tf.float32 , tf.int32 etc. Du kan hänvisa till dem alla över här .

Konstanter initialiseras när du ringer tf. konstant , och deras värde kan aldrig förändras. Tvärtom initialiseras inte variabler när du ringer tf. variabel . För att initialisera alla variabler i ett TensorFlow-program, du måste uttryckligen anropa en speciell operation som visas nedan:

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

Kom alltid ihåg att en variabel måste initialiseras innan ett diagram används för första gången.

Notera: TensorFlow-variabler är minnesbuffertar som innehåller tensorer, men till skillnad från normala tensorer som bara instanseras när en graf körs och omedelbart raderas efteråt, överlever variabler över flera körningar av en graf.

Nu när vi har täckt tillräckligt med grunderna i TensorFlow, låt oss gå vidare och förstå hur man implementerar en linjär regressionsmodell med TensorFlow.

Linjär regressionsmodell med TensorFlow

Linjär regressionsmodell används för att förutsäga det okända värdet på en variabel (beroende variabel) från det kända värdet på en annan variabel (oberoende variabel) med linjär regressionsekvation som visas nedan:

För att skapa en linjär modell behöver du därför:

  1. Beroende eller outputvariabel (Y)
  2. Lutningsvariabel (w)
  3. Y - Avlyssning eller förspänning (b)
  4. Oberoende eller ingångsvariabel (X)

Så, låt oss börja bygga linjär modell med TensorFlow:

hur man gör en ordbok i java

Kopiera koden genom att klicka på knappen nedan:

# Skapa variabel för parameterlutning (W) med initialvärde som 0,4 W = tf.Variable ([. 4], tf.float32) # Skapa variabel för parameterbias (b) med initialvärde som -0.4 b = tf.Variable ( [-0.4], tf.float32) # Skapa platshållare för att tillhandahålla inmatning eller oberoende variabel, betecknad med xx = tf.placeholder (tf.float32) # Ekvation av linjär regression linjär_modell = W * x + b # Initiera alla variabler sess = tf.Session () init = tf.global_variables_initializer () sess.run (init) # Kör regressionsmodell för att beräkna output wrt till angivna x-värden skriv ut (sess.run (linjär_modell {x: [1, 2, 3, 4]}))

Produktion:

[0. 0.40000001 0.80000007 1.20000005]

Ovanstående kod representerar bara grundidén bakom implementeringen av regressionsmodellen, dvs hur du följer regressionslinjens ekvation för att få utdata w.r.t. en uppsättning ingångsvärden. Men det finns ytterligare två saker kvar att lägga till i den här modellen för att göra den till en komplett regressionsmodell:

  • Först måste vi tillhandahålla en mekanism genom vilken vår modell kan träna sig automatiskt baserat på en viss uppsättning ingångar och respektive utgångar.
  • Det andra vi behöver är att validera vår utbildade modell genom att jämföra dess utdata med önskad eller målutgång baserat på en given uppsättning x-värden.

Låt oss nu förstå hur kan jag införliva ovan angivna funktioner i min kod för regressionsmodell.

Förlustfunktion - modellvalidering

En förlustfunktion mäter hur långt ifrån varandra den nuvarande produktionen för modellen är från den för önskad eller målutgång. Jag använder en vanligaste förlustfunktion för min linjära regressionsmodell kallad Sum of Squared Error eller SSE. SSE beräknad w.r.t. modelloutput (representeras av linjär_modell) och önskad eller målutgång (y) som:

y = tf.placeholder (tf.float32) fel = linjär_modell - y kvadrerade fel = tf.square (fel) förlust = tf.reduce_sum (kvadrerade fel) tryck (sess.run (förlust, {x: [1,2,3,4 ], y: [2, 4, 6, 8]})
 Produktion: 90,24

Som du kan se får vi ett högt förlustvärde. Därför måste vi justera våra vikter (W) och bias (b) för att minska det fel som vi får.

tf.train API - Utbildning av modellen

TensorFlow tillhandahåller optimerare som långsamt ändrar varje variabel för att minimera förlustfunktionen eller felet. Den enklaste optimeraren är gradient nedstigning . Den ändrar varje variabel i enlighet med storleken på förlustderivatet med avseende på den variabeln.

# Skapa en instans av optimering för gradientnedstigningsoptimering = tf.train.GradientDescentOptimizer (0.01) train = optimizer.minimera (förlust) för i inom intervallet (1000): sess.run (train, {x: [1, 2, 3, 4], y: [2, 4, 6, 8]}) tryck (sess.run ([W, b]))
 Produktion: [array ([1.99999964], dtype = float32), array ([9.86305167e-07], dtype = float32)]

Så här skapar du en linjär modell med TensorFlow och tränar den för att få önskad effekt.

Nu när du känner till Deep Learning, kolla in av Edureka, ett pålitligt inlärningsföretag online med ett nätverk av mer än 250 000 nöjda elever spridda över hela världen. Edureka Deep Learning with TensorFlow Certification Training-kursen hjälper eleverna att bli expert på utbildning och optimering av grundläggande och konvolutionsneurala nätverk med hjälp av realtidsprojekt och uppdrag tillsammans med begrepp som SoftMax-funktion, Auto-encoder Neural Networks, Restricted Boltzmann Machine (RBM).

Har du en fråga till oss? Vänligen nämna det i kommentarfältet så återkommer vi till dig.