TensorFlow Tutorial - Deep Learning Using TensorFlow

Jeg har designet denne TensorFlow-opplæringen for fagpersoner og entusiaster som er interessert i å bruke Deep Learning Algorithm ved hjelp av TensorFlow for å løse ulike problemer. TensorFlow er et open source deep learning-bibliotek som er basert på konseptet med dataflytgrafer for å bygge modeller. Det lar deg lage store nevrale nettverk med mange lag.Å lære bruk av dette biblioteket er også en grunnleggende del av biblioteket .Følgende er emnene som vil bli diskutert i denne TensorFlow opplæringsbloggen:

• Hva er TensorFlow
• Grunnleggende om TensorFlow Code
• TensorFlow UseCase

Hva er tensorer?

Før vi snakker om TensorFlow, i denne TensorFlow-opplæringen, la oss først forstå hva er tensorer . Tensorer er ikke annet enn en de facto for å representere dataene i dyp læring.

Som vist på bildet ovenfor, er tensorer bare flerdimensjonale matriser, som lar deg representere data med høyere dimensjoner. Generelt handler Deep Learning om høydimensjonale datasett der dimensjoner refererer til forskjellige funksjoner som er tilstede i datasettet. Navnet “TensorFlow” har faktisk blitt hentet fra operasjonene som nevrale nettverk utfører på tensorer. Det er bokstavelig talt en strøm av tensorer. Siden du har forstått hva som er tensorer, la oss gå videre i denne TensorFlow-opplæringen og forstå - hva er TensorFlow?

Hva er TensorFlow?

TensorFlow er et bibliotek basert på Python som gir forskjellige typer funksjonalitet for implementering av Deep Learning Models. Som diskutert tidligere, består begrepet TensorFlow av to termer - Tensor & Flow:

I TensorFlow refererer begrepet tensor til fremstilling av data som flerdimensjonalt array, mens begrepet flow refererer til rekken av operasjoner som man utfører på tensorer som vist i bildet ovenfor.

hvordan du bruker spyder python

Nå har vi dekket nok bakgrunn om TensorFlow.

Neste gang, i denne TensorFlow-opplæringen, vil vi diskutere om TensorFlow-kodegrunnleggende.

TensorFlow Tutorial: Code Basics

I utgangspunktet involverer den generelle prosessen med å skrive et TensorFlow-program to trinn:

1. Bygg en beregningsgraf
2. Kjøre en beregningsgraf

La meg forklare deg de to ovennevnte trinnene en etter en:

1. Bygg en beregningsgraf

Så, hva er en beregningsgraf? En beregningsgraf er en serie TensorFlow-operasjoner ordnet som noder i grafen. Hver node tar 0 eller flere tensorer som input og produserer en tensor som output. La meg gi deg et eksempel på en enkel beregningsgraf som består av tre noder - til , b & c som vist under:

Forklaring til beregningsdiagrammet ovenfor:

• Konstant noderbrukes til å lagre konstante verdier ettersom det tar null inngang, men produserer de lagrede verdiene som utdata. I eksemplet ovenfor er a og b konstante noder med henholdsvis verdiene 5 og 6.

• Noden c representerer operasjonen med å multiplisere konstant node a med b. Derfor vil kjøring av node c resultere i multiplikasjon av const node a & b.

I utgangspunktet kan man tenke på en beregningsgraf som en alternativ måte å konseptualisere matematiske beregninger som foregår i et TensorFlow-program. Operasjonene tilordnet forskjellige noder i en beregningsgraf kan utføres parallelt, og gir dermed bedre ytelse når det gjelder beregninger.

Her beskriver vi bare beregningen, den beregner ikke noe, den inneholder ingen verdier, den definerer bare operasjonene som er spesifisert i koden din.

2. Kjøre en beregningsgraf

La oss ta det forrige eksemplet på beregningsgraf og forstå hvordan vi skal utføre det. Følgende er koden fra forrige eksempel:

Eksempel 1:

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

Nå, for å få utdata fra node c, må vi kjøre beregningsgrafen innenfor a økt . Session plasserer grafoperasjonene på enheter, for eksempel CPUer eller GPUer, og gir metoder for å utføre dem.

En økt innkapsler kontrollen og tilstanden til TensorFlow-kjøretiden, dvs. den lagrer informasjonen om rekkefølgen som alle operasjonene skal utføres i, og sender resultatet av allerede beregnet drift til neste operasjon i rørledningen. La meg vise deg hvordan du kjører beregningsgrafen ovenfor i en økt (Forklaring av hver kodelinje er lagt til som en kommentar):

# Opprett sesjonsobjektet sess = tf.Session () # Kjør grafen i en økt og lagre utgangen til en variabel output_c = sess.run (c) # Skriv ut utgangen til node c print (output_c) #Lukk økten til frigjør noen ressurser sess.close ()

 Produksjon: 30

Så alt handlet om økt og kjøring av et beregningsdiagram i det. La oss nå snakke om variabler og plassholdere som vi vil bruke mye mens vi bygger dyp læringsmodell ved bruk av TensorFlow.

Konstanter, plassholder og variabler

I TensorFlow brukes konstanter, plassholdere og variabler til å representere forskjellige parametere for en dyp læringsmodell. Siden jeg allerede har diskutert konstanter tidligere, vil jeg starte med plassholdere.

Plassholder:

En TensorFlow-konstant lar deg lagre en verdi, men hva om du vil at nodene dine skal ta innganger på rømmen? For denne typen funksjonalitet brukes plassholdere som gjør at grafen din kan ta eksterne innganger som parametere. I utgangspunktet er en plassholder et løfte om å gi en verdi senere eller i løpet av kjøretiden. La meg gi deg et eksempel for å gjøre ting enklere:

importer tensorflow som tf # Opprette plassholdere a = tf. plassholder (tf.float32) b = tf. plassholder (tf.float32) # Tilordne multiplikasjonsoperasjon w.r.t. a & ampamp b til node mul mul = a * b # Opprett sesjonsobjekt sess = tf.Session () # Utføre mul ved å overføre verdiene [1, 3] [2, 4] for henholdsvis a og b output = sess.run ( mul, {a: [1,3], b: [2, 4]}) utskrift ('Multiplikasjon ab:', utgang)

 Produksjon: [2. 12.]

Poeng å huske på plassholdere:

• Plassholdere initialiseres ikke og inneholder ingen data.
• Man må gi input eller feeds til plassholderen som vurderes i løpet av kjøretiden.
• Å utføre en plassholder uten input genererer en feil.

La oss nå gå videre og forstå - hva er variabler?

Variabler

I dyp læring brukes plassholdere til å ta vilkårlige innganger i modellen eller grafen din. Bortsett fra å ta input, må du også endre grafen slik at den kan produsere nye utganger w.r.t. samme innganger. For dette vil du bruke variabler. I et nøtteskall lar en variabel deg legge til slike parametere eller noder i grafen som kan trenes, dvs. verdien kan endres over en periode. Variabler defineres ved å oppgi deres opprinnelige verdi og type som vist nedenfor:

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

Merk:

• Hvis du ikke har oppgitt datatypen eksplisitt, vil TensorFlow utlede typen konstant / variabel fra den initialiserte verdien.
• TensorFlow har mange av 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 verdien deres kan aldri endres. Tvert imot initialiseres ikke variabler når du ringer tf. variabel . For å initialisere alle variablene i et TensorFlow-program, må du må eksplisitt kalle en spesiell operasjon som vist nedenfor:

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

Husk alltid at en variabel må initialiseres før en graf brukes for første gang.

Merk: TensorFlow-variabler er buffere i minnet som inneholder tensorer, men i motsetning til normale tensorer som bare instantieres når en graf kjøres og umiddelbart slettes etterpå, overlever variabler over flere utførelser av en graf.

Nå som vi har dekket nok grunnleggende om TensorFlow, la oss gå videre og forstå hvordan vi implementerer en lineær regresjonsmodell ved bruk av TensorFlow.

Lineær regresjonsmodell ved bruk av TensorFlow

Lineær regresjonsmodell brukes til å forutsi den ukjente verdien av en variabel (avhengig variabel) fra den kjente verdien til en annen variabel (uavhengig variabel) ved hjelp av lineær regresjonsligning som vist nedenfor:

Derfor, for å lage en lineær modell, trenger du:

1. Avhengig eller utgangsvariabel (Y)
2. Helningsvariabel (w)
3. Y - Avskjær eller skjevhet (b)
4. Uavhengig eller inngangsvariabel (X)

Så la oss begynne å bygge lineær modell ved hjelp av TensorFlow:

Kopier koden ved å klikke på knappen nedenfor:

# Opprette variabel for parameterhelling (W) med opprinnelig verdi som 0,4 W = tf.Variabel ([. 4], tf.float32) # Opprette variabel for parameter bias (b) med startverdi som -0,4 b = tf.Variable ( [-0.4], tf.float32) # Opprette plassholdere for å gi input eller uavhengig variabel, betegnet med xx = tf.placeholder (tf.float32) # Ligning av lineær regresjon linear_model = W * x + b # Initialisering av alle variablene sess = tf.Session () init = tf.global_variables_initializer () sess.run (init) # Kjører regresjonsmodell for å beregne utgangsverdien til gitt x-verdier skrives ut (sess.run (linear_model {x: [1, 2, 3, 4]}))

Produksjon:

[0. 0.40000001 0.80000007 1.20000005]

Ovennevnte kode representerer bare den grunnleggende ideen bak implementeringen av regresjonsmodellen, dvs. hvordan du følger ligningen av regresjonslinjen for å få utgang w.r.t. et sett med inngangsverdier. Men det er to ting igjen å legge til i denne modellen for å gjøre den til en komplett regresjonsmodell:

• Først må vi tilby en mekanisme der modellen vår kan trene seg selv automatisk basert på gitt sett med innganger og respektive utganger.
• Den andre tingen vi trenger er å validere vår trente modell ved å sammenligne utdataene med ønsket eller målutgang basert på et gitt sett med x-verdier.

La oss nå forstå hvordan jeg kan innlemme de ovennevnte funksjonene i koden for regresjonsmodell.

Tapfunksjon - modellvalidering

En tapsfunksjon måler hvor langt fra hverandre den nåværende utgangen til modellen fra den for ønsket eller ønsket utgang. Jeg bruker en mest brukte tapsfunksjon for min lineære regresjonsmodell kalt Sum of Squared Error eller SSE. SSE beregnet w.r.t. modellutgang (representert ved linear_model) og ønsket eller målutgang (y) som:

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

 Produksjon: 90,24

Som du ser, får vi en høy tapverdi. Derfor må vi justere vektene (W) og skjevheten (b) for å redusere feilen vi mottar.

tf.train API - Opplæring av modellen

TensorFlow gir optimaliserere som sakte endrer hver variabel for å minimere tapsfunksjonen eller feilen. Den enkleste optimalisereren er gradient nedstigning . Den modifiserer hver variabel i henhold til størrelsen på derivatet av tap i forhold til den variabelen.

salgsutviklerveiledning for nybegynnere

# Opprette en forekomst av gradientnedstigningsoptimaliseringsoptimalisering = tf.train.GradientDescentOptimizer (0.01) tog = optimizer.minimer (tap) for jeg i rekkevidde (1000): sess.run (tog, {x: [1, 2, 3, 4], y: [2, 4, 6, 8]}) utskrift (sess.run ([W, b]))

 Produksjon: [array ([1.99999964], dtype = float32), array ([9.86305167e-07], dtype = float32)]

Så dette er hvordan du oppretter en lineær modell ved hjelp av TensorFlow og trener den for å få ønsket produksjon.

Nå som du vet om Deep Learning, sjekk ut av Edureka, et pålitelig online læringsfirma med et nettverk av mer enn 250 000 fornøyde elever spredt over hele verden. Edureka Deep Learning with TensorFlow Certification Training-kurset hjelper elever til å bli eksperter i å trene og optimalisere grunnleggende og konvolusjonelle nevrale nettverk ved hjelp av sanntidsprosjekter og oppgaver sammen med konsepter som SoftMax-funksjon, Auto-encoder Neural Networks, Restricted Boltzmann Machine (RBM).

Har du et spørsmål til oss? Vennligst nevn det i kommentarfeltet, så kommer vi tilbake til deg.