Python Tensorflow-handledning

I den här lektionen ska vi titta på TensorFlow, som är ett bibliotek med öppen källkod för maskininlärning som används för att designa, bygga och träna djupinlärningsmodeller. Det är möjligt att utföra numeriska beräkningar med TensorFlow-biblioteket, vilka dataflödesdiagram där matematiska operationer representeras som noder och data representeras som kanter mellan dessa noder.

Sammantaget kommer vi att täcka tre huvudämnen i den här lektionen:

Vad är Tensors och TensorFlow
Tillämpa ML-algoritmer med TensorFlow
TensorFlow användningsfall

TensorFlow är ett utmärkt Python-paket från Google som använder sig av dataflödets programmeringsparadigm för mycket optimerade matematiska beräkningar. Några av funktionerna i TensorFlow är:

Distribuerad beräkningskapacitet som underlättar hantering av data i stora uppsättningar
Djupt lärande och neuralt nätverksstöd är bra
Det hanterar komplexa matematiska strukturer som n-dimensionella matriser mycket effektivt

På grund av alla dessa funktioner och utbudet av maskininlärningsalgoritmer gör TensorFlow det till ett bibliotek i produktionsskala. Låt oss dyka in i koncept i TensorFlow så att vi kan göra våra händer smutsiga med kod direkt efter.

Installera TensorFlow

Eftersom vi kommer att använda Python API för TensorFlow är det bra att veta att det fungerar med både Python 2.7 och 3.3+ versioner. Låt oss installera TensorFlow-biblioteket innan vi går till de faktiska exemplen och koncepten. Det finns två sätt att installera detta paket. Den första inkluderar att använda Python-pakethanteraren, pip:

pip installera tensorflow

Det andra sättet gäller Anaconda, vi kan installera paketet som:

conda install -c conda-forge tensorflow

Titta gärna efter nattliga byggnader och GPU-versioner på de officiella installationssidorna för TensorFlow.

Jag kommer att använda Anaconda-chefen för alla exemplen i den här lektionen. Jag kommer att starta en Jupyter Notebook för samma:

Nu när vi är redo med alla importuttalanden för att skriva lite kod, låt oss börja dyka in i SciPy-paketet med några praktiska exempel.

Vad är Tensorer?

Tensorer är de grundläggande datastrukturerna som används i Tensorflow. Ja, de är bara ett sätt att representera data i djupinlärning. Låt oss visualisera dem här:

Som beskrivs i bilden, tensorer kan betecknas som n-dimensionell matris vilket gör att vi kan representera data i komplexa dimensioner. Vi kan tänka på varje dimension som ett annat inslag i data vid djupinlärning. Detta innebär att Tensorer kan växa ut till att vara ganska komplexa när det gäller komplexa datamängder med många funktioner.

När vi väl vet vad Tensorer är tycker jag att det är ganska lätt att härleda vad som händer i TensorFlow. Dessa termer betyder hur tensorer eller funktioner kan flöda i datamängder för att producera värdefull effekt när vi utför olika operationer på den.

Förstå TensorFlow med konstanter

Precis som vi läser ovan tillåter TensorFlow oss att utföra maskininlärningsalgoritmer på Tensorer för att producera värdefull effekt. Med TensorFlow är det enkelt att designa och träna Deep Learning-modeller.

TensorFlow levereras med byggnad Beräkningsdiagram. Beräkningsdiagram är dataflödesdiagrammen där matematiska operationer representeras som noder och data representeras som kanter mellan dessa noder. Låt oss skriva ett mycket enkelt kodavsnitt för att ge en konkret visualisering:

importera tensorflöde som tf
x = tf.konstant (5)
y = tf.konstant (6)
z = x * y
skriva ut (z)

När vi kör det här exemplet ser vi följande utdata:

Varför är multiplikationen fel? Det var inte vad vi förväntade oss. Detta hände eftersom det inte är så vi kan utföra operationer med TensorFlow. Först måste vi starta en session för att få beräkningsdiagrammet att fungera,

Med Sessions kan vi kapsla in kontroll av drift och tillstånd för Tensorer. Detta innebär att en session också kan lagra resultatet av en beräkningsgraf så att den kan skicka resultatet till nästa operation i ordningen för genomförandet av rörledningarna. Låt oss skapa en session nu för att få rätt resultat:

# Börja med sessionsobjektet
session = tf.Session()
# Ge beräkningen till sessionen och lagra den
resultat = session.springa (z)
# Skriv ut resultatet av beräkningen
skriva ut (resultat)
# Stäng session
session.stänga()

Den här gången fick vi sessionen och gav den den beräkning som den behöver för att köra på noderna. När vi kör detta exempel ser vi följande utdata:

Även om vi fick en varning från TensorFlow, fick vi fortfarande rätt resultat från beräkningen.

Tensoroperationer med ett element

Precis som det vi multiplicerade med två konstanta Tensorer i det sista exemplet, har vi många andra operationer i TensorFlow som kan utföras på enskilda element:

Lägg till
subtrahera
multiplicera
div
mod
magmuskler
negativ
tecken
fyrkant
runda
sqrt
pow
exp
logga
maximal
minimum
cos
synd

Enkelelementoperationer betyder att även när du tillhandahåller en matris kommer operationerna att utföras på vart och ett av elementen i den matrisen. Till exempel:

importera tensorflöde som tf
importera numpy som np
tensor = np.array ([2, 5, 8])
tensor = tf.convert_to_tensor (tensor, dtype = tf.float64)
med tf.Session () som session:
skriva ut (session.kör (tf.cos (tensor)))

När vi kör det här exemplet ser vi följande utdata:

Vi förstod två viktiga begrepp här:

Vilken NumPy-matris som helst kan enkelt konverteras till en Tensor med hjälp av funktionen convert_to_tensor
Åtgärden utfördes på vart och ett av NumPy-arrayelementet

Platshållare och variabler

I ett av föregående avsnitt tittade vi på hur vi kan använda Tensorflow-konstanter för att göra beräkningsdiagram. Men TensorFlow tillåter oss också att ta inmatningar på språng så att beräkningsdiagrammet kan vara dynamiskt. Detta är möjligt med hjälp av platshållare och variabler.

I själva verket innehåller platshållare ingen data och måste tillhandahållas giltiga ingångar under körning och som förväntat, utan en inmatning, kommer de att generera ett fel.

En platshållare kan betecknas som en överenskommelse i ett diagram om att en ingång säkert kommer att tillhandahållas vid körning. Här är ett exempel på platshållare:

importera tensorflöde som tf
# Två platshållare
x = tf. platshållare (tf.float32)
y = tf. platshållare (tf.float32)
# Tilldela multiplikationsoperation w.r.t. a & b till nodmul
z = x * y
# Skapa en session
session = tf.Session()
# Skicka värden för platshållare
resultat = session.kör (z, x: [2, 5], y: [3, 7])
skriv ut ('Multiplicera x och y:', resultat)

När vi kör det här exemplet ser vi följande utdata:

Nu när vi har kunskap om platshållare, låt oss vända blicken mot variabler. Vi vet att utgången från en ekvation kan förändras för samma uppsättning ingångar över tiden. Så när vi tränar vår modellvariabel kan den ändra sitt beteende över tiden. I det här scenariot tillåter en variabel oss att lägga till dessa träningsbara parametrar i vårt beräkningsdiagram. En variabel kan definieras enligt följande:

x = tf.Variabel ([5.2], dtype = tf.float32)

I ovanstående ekvation är x en variabel som tillhandahålls dess ursprungliga värde och datatyp. Om vi inte tillhandahåller datatypen kommer TensorFlow att dra slutsatsen om dess ursprungliga värde. Se datatyperna för TensorFlow här.

Till skillnad från en konstant måste vi anropa en Python-funktion för att initialisera alla variabler i en graf:

init = tf.global_variables_initializer ()
session.kör (init)

Se till att köra ovanstående TensorFlow-funktion innan vi använder vår graf.

Linjär regression med TensorFlow

Linjär regression är en av de vanligaste algoritmerna som används för att etablera en relation i en given kontinuerlig data. Detta förhållande mellan koordinatpunkterna, säg x och y, kallas a hypotes. När vi pratar om linjär regression är hypotesen en rak linje:

y = mx + c

Här är m linjens lutning och här är det en vektor som representerar vikter. c är den konstanta koefficienten (y-avlyssning) och här representerar den Partiskhet. Vikt och förspänning kallas parametrar för modellen.

Linjära regressioner gör att vi kan uppskatta värdena på vikt och förspänning så att vi har ett minimum Kostnadsfunktion. Slutligen är x den oberoende variabeln i ekvationen och y är den beroende variabeln. Låt oss börja bygga den linjära modellen i TensorFlow med ett enkelt kodavsnitt som vi kommer att förklara:

importera tensorflöde som tf
# Variabler för parameterlutning (W) med initialvärde som 1.1
W = tf.Variabel ([1.1], tf.float32)
# Variabel för förspänning (b) med initialt värde som -1.1
b = tf.Variabel ([- 1.1], tf.float32)
# Platshållare för att tillhandahålla input eller oberoende variabel, betecknad med x
x = tf.platshållare (tf.float32)
# Linjeekvation eller linjär regression
linjär_modell = W * x + b
# Initiera alla variabler
session = tf.Session()
init = tf.global_variables_initializer ()
session.kör (init)
# Utför regressionsmodell
skriva ut (session.kör (linjär_modell x: [2, 5, 7, 9]))

Här gjorde vi precis vad vi förklarade tidigare, låt oss sammanfatta här:

Vi började med att importera TensorFlow till vårt skript
Skapa några variabler för att representera vektorn och parameterförspänningen
En platshållare behövs för att representera ingången, x
Representera den linjära modellen
Initiera alla värden som behövs för modellen

När vi kör det här exemplet ser vi följande utdata:

Det enkla kodavsnittet ger bara en grundläggande idé om hur vi kan bygga en regressionsmodell. Men vi behöver fortfarande göra några fler steg för att slutföra modellen vi byggde:

Vi måste göra vår modell självutbildbar så att den kan producera utdata för alla ingångar
Vi måste validera utdata från modellen genom att jämföra den med den förväntade utgången för givna x

Förlustfunktion och modellvalidering

För att validera modellen måste vi ha ett mått på hur avvikande strömutgång är från den förväntade utgången. Det finns olika förlustfunktioner som kan användas här för validering men vi kommer att titta på en av de vanligaste metoderna, Summan av kvadratfel eller SSE.

Ekvationen för SSE ges som:

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

Här:

E = medelkvadratfel
t = Mottagen utgång
y = Förväntad utgång
t - y = Fel

Låt oss nu skriva ett kodavsnitt i fortsättning till det sista utdraget för att återspegla förlustvärdet:

y = tf.platshållare (tf.float32)
fel = linjär_modell - y
squared_errors = tf.kvadrat (fel)
förlust = tf.minska_sum (kvadratfel)
skriva ut (session.kör (förlust, x: [2, 5, 7, 9], y: [2, 4, 6, 8])

När vi kör detta exempel ser vi följande utdata:

Det är uppenbart att förlustvärdet är mycket lågt för den givna linjära regressionsmodellen.

Slutsats

I den här lektionen tittade vi på ett av de mest populära paketet Deep Learning and Machine Learning, TensorFlow. Vi gjorde också en linjär regressionsmodell som hade mycket hög noggrannhet.