TensorFlow-zelfstudie - diep leren met behulp van TensorFlow

De TensorFlow-tutorial is de derde blog in de serie. Het bevat alle basisprincipes van TensorFlow. Er wordt ook gesproken over hoe u een eenvoudig lineair model kunt maken.

Ik heb deze TensorFlow-tutorial ontworpen voor professionals en enthousiastelingen die geïnteresseerd zijn in het toepassen van Deep Learning Algorithm met behulp van TensorFlow om verschillende problemen op te lossen. TensorFlow is een open source deep learning-bibliotheek die is gebaseerd op het concept van gegevensstroomgrafieken voor het bouwen van modellen. Hiermee kunt u grootschalige neurale netwerken met veel lagen maken.Het leren gebruiken van deze bibliotheek is ook een fundamenteel onderdeel van het .Hieronder volgen de onderwerpen die in deze TensorFlow-tutorialblog zullen worden besproken:

  • Wat is TensorFlow
  • TensorFlow Code Basics
  • TensorFlow UseCase

Wat zijn tensoren?

Laten we in deze TensorFlow-tutorial eerst begrijpen voordat we het hebben over TensorFlow wat zijn tensoren . Tensoren zijn niets anders dan de facto om de gegevens in deep learning weer te geven.



Tensoren - TensorFlow-zelfstudie - EdurekaZoals te zien is in de bovenstaande afbeelding, zijn tensoren slechts multidimensionale arrays, waarmee u gegevens met hogere dimensies kunt weergeven. Over het algemeen heb je bij Deep Learning te maken met hoog-dimensionale datasets waarbij dimensies verwijzen naar verschillende features in de dataset. In feite is de naam 'TensorFlow' afgeleid van de operaties die neurale netwerken uitvoeren op tensoren. Het is letterlijk een stroom van tensoren. Omdat je hebt begrepen wat tensoren zijn, laten we verder gaan in deze TensorFlow-tutorial en begrijpen - wat is TensorFlow?

Wat is TensorFlow?

TensorFlow is een bibliotheek gebaseerd op Python die verschillende soorten functionaliteit biedt voor het implementeren van Deep Learning-modellen. Zoals eerder besproken, bestaat de term TensorFlow uit twee termen: Tensor & Flow:

In TensorFlow verwijst de term tensor naar de weergave van gegevens als een multidimensionale array, terwijl de term flow verwijst naar de reeks bewerkingen die men uitvoert op tensoren, zoals weergegeven in de bovenstaande afbeelding.

Nu hebben we genoeg achtergrondinformatie over TensorFlow besproken.

Vervolgens bespreken we in deze TensorFlow-tutorial over TensorFlow-codebasis.

TensorFlow-zelfstudie: basisprincipes van code

Kortom, het algemene proces van het schrijven van een TensorFlow-programma omvat twee stappen:

  1. Een computationele grafiek bouwen
  2. Een computergrafiek uitvoeren

Laat me je de bovenstaande twee stappen een voor een uitleggen:

1. Een computergrafiek maken

Zo, wat is een computationele grafiek? Welnu, een computergrafiek is een reeks TensorFlow-bewerkingen die zijn gerangschikt als knooppunten in de grafiek. Elk knooppunt heeft 0 of meer tensoren als invoer en produceert een tensor als uitvoer. Ik zal u een voorbeeld geven van een eenvoudige computergrafiek die uit drie knooppunten bestaat - naar , b & c zoals hieronder weergegeven:

Uitleg van de bovenstaande computergrafiek:

  • Constante knooppuntenworden gebruikt om constante waarden op te slaan aangezien er geen invoer nodig is, maar produceert de opgeslagen waarden als uitvoer. In het bovenstaande voorbeeld zijn a en b constante knooppunten met respectievelijk waarden 5 en 6.

    is master een postdoctorale opleiding
  • Het knooppunt c vertegenwoordigt de bewerking van het vermenigvuldigen van constant knooppunt a met b. Daarom zal het uitvoeren van knooppunt c resulteren in een vermenigvuldiging van const knooppunt a & b.

In wezen kan men een computationele grafiek zien als een alternatieve manier om wiskundige berekeningen te conceptualiseren die plaatsvinden in een TensorFlow-programma. De bewerkingen die aan verschillende knooppunten van een Computational Graph zijn toegewezen, kunnen parallel worden uitgevoerd, waardoor betere prestaties worden geleverd in termen van berekeningen.

Hier beschrijven we alleen de berekening, het berekent niets, het bevat geen waarden, het definieert alleen de bewerkingen die in uw code zijn gespecificeerd.

2. Een computergrafiek uitvoeren

Laten we het vorige voorbeeld van een computationele grafiek nemen en begrijpen hoe deze moet worden uitgevoerd. Hieronder volgt de code uit het vorige voorbeeld:

Voorbeeld 1:

importeer tensorflow als tf # Bouw een grafiek a = tf.constant (5.0) b = tf.constant (6.0) c = a * b

Om de uitvoer van knooppunt c te krijgen, moeten we nu de rekengrafiek uitvoeren binnen a sessie . Session plaatst de grafiekbewerkingen op apparaten, zoals CPU's of GPU's, en biedt methoden om deze uit te voeren.

Een sessie omvat de controle en status van de TensorFlow-runtime, d.w.z. het slaat de informatie op over de volgorde waarin alle bewerkingen zullen worden uitgevoerd en geeft het resultaat van een reeds berekende bewerking door aan de volgende bewerking in de pijplijn. Ik zal u laten zien hoe u de bovenstaande computergrafiek binnen een sessie kunt uitvoeren (uitleg van elke regel code is als opmerking toegevoegd):

# Maak het sessieobject sess = tf.Session () #Raak de grafiek binnen een sessie en sla de output op in een variabele output_c = sess.run (c) #Print de output van knooppunt c print (output_c) #Sluit de sessie om maak wat bronnen vrij sess.close ()
 Uitgang: 30

Dus dit ging allemaal over sessie en het erin draaien van een computergrafiek. Laten we het nu hebben over variabelen en tijdelijke aanduidingen die we uitgebreid zullen gebruiken bij het bouwen van een model voor diep leren met behulp van TensorFlow.

Constanten, tijdelijke aanduiding en variabelen

In TensorFlow worden constanten, tijdelijke aanduidingen en variabelen gebruikt om verschillende parameters van een deep learning-model weer te geven. Aangezien ik constanten al eerder heb besproken, zal ik beginnen met tijdelijke aanduidingen.

Tijdelijke aanduiding:

Met een TensorFlow-constante kunt u een waarde opslaan, maar wat als u wilt dat uw knooppunten tijdens het uitvoeren invoer opnemen? Voor dit soort functionaliteit worden tijdelijke aanduidingen gebruikt waarmee uw grafiek externe invoer als parameters kan nemen. In feite is een tijdelijke aanduiding een belofte om later of tijdens runtime een waarde te geven. Ik zal u een voorbeeld geven om de zaken eenvoudiger te maken:

import tensorflow als tf # Tijdelijke aanduidingen maken a = tf. tijdelijke aanduiding (tf.float32) b = tf. placeholder (tf.float32) # Toewijzing van vermenigvuldiging w.r.t. a & ampamp b naar knoop mul mul = a * b # Maak sessieobject sess = tf.Session () # Uitvoeren van mul door de waarden [1, 3] [2, 4] door te geven voor respectievelijk a en b output = sess.run ( mul, {a: [1,3], b: [2, 4]}) print ('Vermenigvuldigen ab:', uitvoer)
 Uitgang: [2. 12.]

Punten om te onthouden tijdelijke aanduidingen:

  • Tijdelijke aanduidingen zijn niet geïnitialiseerd en bevatten geen gegevens.
  • Men moet invoer of feeds aan de tijdelijke aanduiding verstrekken die tijdens runtime in aanmerking worden genomen.
  • Het uitvoeren van een tijdelijke aanduiding zonder invoer genereert een fout.

Laten we nu verder gaan en begrijpen - wat zijn variabelen?

Variabelen

Bij deep learning worden tijdelijke aanduidingen gebruikt om willekeurige invoer in uw model of grafiek te nemen. Afgezien van het nemen van invoer, moet u de grafiek ook zodanig aanpassen dat deze nieuwe uitvoer kan produceren w.r.t. dezelfde ingangen. Hiervoor gebruik je variabelen. In een notendop: met een variabele kunt u dergelijke parameters of knooppunten aan de grafiek toevoegen die kunnen worden getraind, d.w.z. de waarde kan in de loop van een tijd worden gewijzigd. Variabelen worden gedefinieerd door hun oorspronkelijke waarde en type op te geven, zoals hieronder weergegeven:

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

Opmerking:

  • Als u het gegevenstype niet expliciet hebt opgegeven, zal TensorFlow het type constante / variabele afleiden uit de geïnitialiseerde waarde.
  • TensorFlow heeft veel van zijn eigen gegevenstypen, zoals tf.float32 , tf.int32 enzovoort. U kunt ze allemaal opnieuw raadplegen hier .

Constanten worden geïnitialiseerd wanneer u belt tf. constant , en hun waarde kan nooit veranderen. Integendeel, variabelen worden niet geïnitialiseerd wanneer u belt tf.Variabele . Om alle variabelen in een TensorFlow-programma te initialiseren, moet u moet roep expliciet een speciale bewerking aan zoals hieronder weergegeven:

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

Onthoud altijd dat een variabele moet worden geïnitialiseerd voordat een grafiek voor de eerste keer wordt gebruikt.

Opmerking: TensorFlow-variabelen zijn buffers in het geheugen die tensoren bevatten, maar in tegenstelling tot normale tensoren die alleen worden geïnstantieerd wanneer een grafiek wordt uitgevoerd en onmiddellijk daarna worden verwijderd, overleven variabelen bij meerdere uitvoeringen van een grafiek.

Nu we genoeg basisprincipes van TensorFlow hebben behandeld, gaan we door met het implementeren van een lineair regressiemodel met TensorFlow.

Lineair regressiemodel met TensorFlow

Lineair regressiemodel wordt gebruikt voor het voorspellen van de onbekende waarde van een variabele (afhankelijke variabele) op basis van de bekende waarde van een andere variabelen (onafhankelijke variabele) met behulp van een lineaire regressievergelijking, zoals hieronder weergegeven:

Daarom heeft u voor het maken van een lineair model het volgende nodig:

  1. Afhankelijke of uitvoervariabele (Y)
  2. Hellingsvariabele (w)
  3. Y - Onderschepping of bias (b)
  4. Onafhankelijke of ingangsvariabele (X)

Laten we dus beginnen met het bouwen van een lineair model met TensorFlow:

Kopieer de code door op de onderstaande knop te klikken:

# Variabele maken voor parameterhelling (W) met beginwaarde als 0,4 W = tf.Variable ([. 4], tf.float32) # Variabele maken voor parameterbias (b) met beginwaarde als -0,4 b = tf.Variable ( [-0.4], tf.float32) # Tijdelijke aanduidingen maken voor het leveren van invoer of onafhankelijke variabelen, aangeduid met xx = tf.placeholder (tf.float32) # Vergelijking van lineaire regressie linear_model = W * x + b # Initialiseren van alle variabelen sess = tf.Session () init = tf.global_variables_initializer () sess.run (init) # Regressiemodel uitvoeren om de output tov te berekenen om x-waarden af ​​te drukken (sess.run (linear_model {x: [1, 2, 3, 4]}))

Uitgang:

[0. 0.40000001 0.80000007 1.20000005]

De hierboven vermelde code vertegenwoordigt slechts het basisidee achter de implementatie van een regressiemodel, d.w.z. hoe u de regressievergelijking volgt om uitvoer te krijgen t.o.v. een set invoerwaarden. Maar er zijn nog twee dingen die aan dit model moeten worden toegevoegd om er een compleet regressiemodel van te maken:

  • Ten eerste moeten we een mechanisme bieden waarmee ons model zichzelf automatisch kan trainen op basis van een gegeven set inputs en respectieve outputs.
  • Het tweede dat we nodig hebben, is ons getrainde model valideren door de uitvoer ervan te vergelijken met de gewenste of beoogde uitvoer op basis van een gegeven reeks x-waarden.

Laten we nu eens begrijpen hoe ik de bovengenoemde functionaliteiten kan opnemen in mijn code voor regressiemodel.

Verliesfunctie - Modelvalidatie

Een verliesfunctie meet hoe ver de huidige output van het model verwijderd is van die van de gewenste of beoogde output. Ik gebruik een meest gebruikte verliesfunctie voor mijn lineaire regressiemodel, genaamd Som of Squared Error of SSE. SSE berekend w.r.t. modeluitvoer (vertegenwoordigen door lineair_model) en gewenste of doeluitvoer (y) als:

y = tf.placeholder (tf.float32) error = lineair_model - y squared_errors = tf.square (error) loss = tf.reduce_sum (squared_errors) print (sess.run (verlies, {x: [1,2,3,4 ], y: [2, 4, 6, 8]})
 Uitgang: 90.24

Zoals u kunt zien, krijgen we een hoge verlieswaarde. Daarom moeten we onze gewichten (W) en bias (b) aanpassen om de fout die we ontvangen te verminderen.

tf.train API - Het model trainen

TensorFlow biedt optimizers die langzaam elke variabele veranderen om de verliesfunctie of fout te minimaliseren. De eenvoudigste optimizer is gradiënt afdaling . Het wijzigt elke variabele volgens de grootte van de afgeleide van het verlies met betrekking tot die variabele.

#Een instantie maken van de optimalisatie van de gradiëntafdaling optimizer = tf.train.GradientDescentOptimizer (0.01) train = optimizer.minimize (verlies) voor i binnen bereik (1000): sess.run (trein, {x: [1, 2, 3, 4], y: [2, 4, 6, 8]}) print (sess.run ([W, b]))
 Uitgang: [array ([1.99999964], dtype = float32), array ([9.86305167e-07], dtype = float32)]

Dit is dus hoe je een lineair model maakt met TensorFlow en het traint om de gewenste output te krijgen.

Nu je meer weet over Deep Learning, kun je het door Edureka, een vertrouwd online leerbedrijf met een netwerk van meer dan 250.000 tevreden leerlingen verspreid over de hele wereld. De Edureka Deep Learning met TensorFlow Certification Training-cursus helpt leerlingen expert te worden in het trainen en optimaliseren van basis- en convolutionele neurale netwerken met behulp van real-time projecten en opdrachten, samen met concepten zoals SoftMax-functie, Auto-encoder Neural Networks, Restricted Boltzmann Machine (RBM).

Heeft u een vraag voor ons? Vermeld het in het opmerkingengedeelte en we nemen contact met u op.