Vad är TensorFlow? Hur det fungerar Architecture & funktioner

Vad är TensorFlow?

TensorFlow är en end-to-end-plattform med öppen källkod för att skapa Machine Learning-applikationer. Det är ett symboliskt matematikbibliotek som använder dataflöde och differentierbar programmering för att utföra olika uppgifter fokuserade på träning och slutledning av djupa neurala nätverk. Det låter utvecklare skapa maskininlärningsapplikationer med hjälp av olika verktyg, bibliotek och communityresurser.

För närvarande är det mest kända djupinlärningsbiblioteket i världen Googles TensorFlow. Google tillämpar maskininlärning i sina produkter för att förbättra sökning, översättning, bildtextning och rekommendationer.

TensorFlow Exempel

För att ge ett konkret exempel, Google Användare kan uppleva en snabbare och mer förfinad sökupplevelse med AI. Om användaren skriver ett nyckelord i sökfältet, Google ger ett rekommendation om vad nästa ord kan bli.

Google vill använda maskininlärning för att dra nytta av sina massiva datamängder för att ge användarna den bästa upplevelsen. Tre olika grupper använder maskininlärning:

• Forskare
• Dataforskare
• programmerare

De kan alla använda samma verktygsuppsättning för att samarbeta med varandra och förbättra sin effektivitet.

Google innehåller inte bara stora datamängder, utan driver även enorm beräkningsinfrastruktur, så TensorFlow byggdes för att skalas från början. TensorFlow är ett bibliotek utvecklat av Google Brain Team ska accelerera maskininlärning och forskning om djupa neurala nätverk.

Den byggdes för att köras på flera processorer eller GPU:er och till och med mobila operativsystem, och den har flera omslag på flera språk som Python, C++ or Java.

TensorFlows historia

För ett par år sedan började djupinlärning överträffa alla andra maskininlärningsalgoritmer när de levererade en enorm mängd data. Google såg att den kunde använda dessa djupa neurala nätverk för att förbättra sina tjänster:

• Gmail
• Bild
• Google sökmotor

De byggde ett ramverk som hette TensorFlow så att forskare och utvecklare kunde arbeta med samma modell och sedan distribuera den i en skala som många kunde använda.

TensorFlow släpptes offentligt i november 2015, och version 1.0 följde i februari 2017. Den betydligt större förändringen kom med TensorFlow 2.0 i september 2019, vilket gjorde snabb körning till standard och antog Keras som standard API på hög nivå. Från och med version 2.16 är Keras 3 standard, och samma modellkod kan även köras på JAX eller Py.Torch-backends.

TensorFlow släpps under Apache 2.0-licensen, så du får använda, modifiera och omdistribuera den, inklusive kommersiellt, utan att betala. Google.

Hur TensorFlow fungerar

TensorFlow låter dig bygga dataflödesgrafer och strukturer för att definiera hur data rör sig genom en graf genom att ta indata som en flerdimensionell array som kallas Tensor. Det låter dig konstruera ett flödesschema över operationer som kan utföras på dessa ingångar, som går i ena änden och kommer i andra änden som utdata.

TensorFlow Architecture

TensorFlow-arkitekturen fungerar i tre delar:

• Förbearbetning av data
• Bygg modellen
• Träna och uppskatta modellen

Det kallas TensorFlow eftersom det tar emot indata som en flerdimensionell array, även känd som tensorer. Du kan konstruera en sorts flödesschema av operationer (kallas en graf) som du vill utföra på den ingången. Ingången går in i ena änden, och sedan flödar den genom detta system med flera operationer och kommer ut i den andra änden som utgång.

Var kan TensorFlow köras?

TensorFlows hårdvaru- och mjukvarukrav delas in i två faser:

Utvecklingsfas: det är då du tränar modellen, vanligtvis på en stationär eller bärbar dator.

Körnings- eller inferensfasNär träningen är klar kan modellen köras på många plattformar:

• Desktop körs Windows, macOS eller Linux
• Moln som webbtjänst
• Mobila enheter som iOS och Android

Du kan träna den på flera maskiner och sedan kan du köra den på en annan maskin, när du väl har den utbildade modellen.

Modellen kan tränas och användas på både GPU:er och processorer. GPU:er designades ursprungligen för videospel. Runt 2009 visade Stanford-forskare att GPU:er är extremt effektiva vid matris- och linjäralgebraoperationer som neurala nätverk är beroende av. Djupinlärning förlitar sig mycket på matrismultiplikation. TensorFlow är mycket snabb på att beräkna matrismultiplikationen eftersom den är skriven i C++. Även om det är implementerat i C++, TensorFlow kan nås och kontrolleras av andra språk främst, Python.

En annan viktig egenskap är TensorBoard, som visualiserar grafen, träningsmåtten och viktfördelningen medan modellen körs.

TensorFlow-komponenter

tensor

TensorFlows namn är direkt härlett från dess kärnramverk: tensorI TensorFlow använder alla beräkningar tensorer. En tensor är en vektor or matris av n-dimensioner som representerar alla typer av data. Alla värden i en tensor innehåller identisk datatyp med en känd (eller delvis känd) forma. Formen på data är dimensionaliteten hos matrisen eller matrisen.

En tensor kan härröra från indata eller resultatet av en beräkning. I TensorFlow bedrivs all verksamhet inuti en diagram. Grafen är en uppsättning beräkningar som sker successivt. Varje operation kallas an op-nod och är kopplade till varandra.

Grafen visar operationerna och kopplingarna mellan noderna. Den visar dock inte värdena. Kanten på noderna är tensorn, dvs ett sätt att fylla operationen med data.

Grafer

TensorFlow använder sig av ett graframverk. Grafen samlar och beskriver alla serieberäkningar som gjorts under träningen. Grafen har många fördelar:

• Den körs på flera processorer eller grafikkort, och även på mobila operativsystem
• Portabiliteten av grafen gör det möjligt att bevara beräkningarna för omedelbar eller senare användning. Grafen kan sparas för att exekveras i framtiden.
• Alla beräkningar i grafen görs genom att koppla samman tensorer
  • En graf har noder och kanter. Varje nod bär en matematisk operation och producerar en utdata, medan kanterna beskriver in- och utdataförhållandena mellan noderna. Tensorerna själva rör sig längs kanterna.

Varför är TensorFlow populär?

TensorFlow är allmänt antaget eftersom det är tillgängligt på alla expertisnivåer. Dess API:er täcker allt från en treradig Keras-modell till ett handbyggt CNN eller RNN. Eftersom beräkningen uttrycks som en graf kan TensorBoard visualisera nätverket och göra felsökning mycket enklare. Det kan även driftsättas i stor skala, köras på CPU, GPU och TPU, och på mobil via TensorFlow Lite.

TensorFlow är fortfarande ett av de två mest använda ramverken för djupinlärning på GitHub, tillsammans med Py.Torch.

TensorFlow Algorithms

TensorFlow levereras med högnivåestimatorer för flera klassiska algoritmer. I TensorFlow 1.x användes dessa under tf.estimator:

• Linjär regression: tf.estimator.LinearRegressor
• Klassificering: tf.estimator.LinearClassifier
• Klassificering av djupinlärning: tf.estimator.DNNClassifier
• Bred och djup inlärning: tf.estimator.DNNLinearCombinedClassifier
• Förstärkt trädregression: tf.estimator.BoostedTreesRegressor
• Förstärkt trädklassificering: tf.estimator.BoostedTreesClassifier

TensorFlow kontra PyTorch: Vilken ska du välja?

TensorFlow och PyTorch är de två dominerande ramverken för djupinlärning, och de praktiska skillnaderna har minskat avsevärt sedan TensorFlow 2.0 antog ivrig exekvering.

Det pragmatiska svaret: välj TensorFlow när modellen måste skickas till mobilen, webbläsaren eller en hanterad serverstack, och välj PyTorch när du itererar på modellarkitektur. Keras 3, standardinställningen från TensorFlow 2.16 och framåt, mjukar upp beslutsfattandet ytterligare, eftersom samma Keras-kod kan köras på en TensorFlow-, JAX- eller Py-server.Torch-backend.

Hur beräkningar fungerar i TensorFlow

import numpy as np
import tensorflow as tf

I de två första kodraderna har vi importerat tensorflow som tf. Med Python, är det vanligt att använda ett kort namn för ett bibliotek. Fördelen är att undvika att skriva in bibliotekets fullständiga namn när vi behöver använda det. Till exempel kan vi importera tensorflow som tf, och anropa tf när vi vill använda en tensorflow-funktion

Låt oss öva på det grundläggande arbetsflödet i TensorFlow med enkla TensorFlow-exempel. Låt oss skapa en beräkningsgraf som multiplicerar två tal med varandra.

I exemplet multiplicerar vi X_1 och X_2 med varandra. TensorFlow skapar en nod för att koppla ihop operationen. I vårt exempel kallas det multiplikation. När grafen är bestämd kommer TensorFlows beräkningsmotorer att multiplicera X_1 och X_2 med varandra.

Slutligen kommer vi att köra en TensorFlow-session som kommer att köra beräkningsgrafen med värdena X_1 och X_2 och skriva ut resultatet av multiplikationen.

Låt oss definiera inmatningsnoderna X_1 och X_2. När vi skapar en nod i TensorFlow måste vi välja vilken typ av nod vi vill skapa. Noderna X1 och X2 kommer att vara en platshållarnod. Platshållaren tilldelar ett nytt värde varje gång vi gör en beräkning. Vi kommer att skapa dem som en TF dot-platshållarnod.

Steg 1: Definiera variabeln

X_1 = tf.placeholder(tf.float32, name = "X_1")
X_2 = tf.placeholder(tf.float32, name = "X_2")

En platshållare behöver en datatyp. Dessa är tal, så tf.float32 är rätt val. Namnargumentet är valfritt men användbart, eftersom det är etiketten som visas i TensorBoard-visualiseringen av grafen. X_2 definieras på samma sätt.

Steg 2: Definiera beräkningen

multiply = tf.multiply(X_1, X_2, name = "multiply")

Nu kan vi definiera noden som utför multiplikationsoperationen. I TensorFlow kan vi göra det genom att skapa en tf.multiply-nod.

Vi kommer att skicka in X_1- och X_2-noderna till multiplikationsnoden. Den säger åt tensorflow att länka dessa noder i beräkningsgrafen, så vi ber den att dra värdena från x och y och multiplicera resultatet. Låt oss också ge multiplikationsnoden namnet multiplicera. Det är hela definitionen för vår enkla beräkningsgraf.

Steg 3: Utför operationen

För att utföra operationer i grafen måste vi skapa en session. I TensorFlow görs det med tf.Session(). Nu när vi har en session kan vi be sessionen att köra operationer på vår beräkningsgraf genom att anropa session. För att köra beräkningen behöver vi använda run.

När multiplikationsoperationen körs behöver den värdena för noderna X_1 och X_2, så du matar in dem vid körning. Vi kan göra det genom att ange en parameter som heter feed_dict. Vi skickar värdet 1,2,3 för X_1 och 4,5,6 för X_2.

Vi skriver ut resultatet med print(result). Vi bör se 4, 10 och 18 för 1×4, 2×5 och 3×6

X_1 = tf.placeholder(tf.float32, name = "X_1")
X_2 = tf.placeholder(tf.float32, name = "X_2")

multiply = tf.multiply(X_1, X_2, name = "multiply")

with tf.Session() as session:
    result = session.run(multiply, feed_dict={X_1:[1,2,3], X_2:[4,5,6]})
    print(result)

[ 4. 10. 18.]

Alternativ för att ladda data till TensorFlow

Det första steget innan träning a maskininlärningsalgoritm är att ladda data. Det finns två vanliga sätt att ladda data:

1. Ladda data till minnetDet är den enklaste metoden. Du laddar all din data till minnet som en enda array. Du skriver vanligt Python för detta; inget av det är TensorFlow-specifikt.

2. TensorFlow-datapipelineTensorFlow tillhandahåller ett inbyggt API som laddar data, tillämpar transformationer och matar modellen. Den här metoden fungerar mycket bra, särskilt när du har en stor datamängd. Till exempel är bildposter kända för att vara enorma och inte få plats i minnet. Datapipelinen hanterar minnet på egen hand.

Vilken lösning ska man använda?

Ladda data i minnet

Om din datauppsättning inte är för stor, dvs mindre än 10 gigabyte, kan du använda den första metoden. Data kan passa in i minnet. Du kan använda ett berömt bibliotek som heter Pandas för att importera CSV-filer. Du kommer att lära dig mer om pandor i nästa handledning.

Ladda data med TensorFlow-pipelinen

Den andra metoden fungerar bäst om du har en stor datamängd. Till exempel, om du har en datauppsättning på 50 gigabyte och din dator bara har 16 gigabyte minne så kommer maskinen att krascha.

I den här situationen behöver du bygga en TensorFlow-pipeline. Pipelinen kommer att ladda data i batcher, eller små bitar. Varje batch kommer att skickas till pipelinen och vara redo för träning. Att bygga en pipeline är en utmärkt lösning eftersom den låter dig använda parallell beräkning. Det innebär att TensorFlow kommer att träna modellen över flera processorer. Det snabbar upp beräkningen och gör det praktiskt att träna större nätverk.

Kort sagt: ladda små datamängder i minnet med pandor, och använd en TensorFlow-pipeline när datamängden är stor eller när du vill ha parallell laddning över flera processorer.

Hur man skapar TensorFlow Pipeline

Här är stegen för att skapa en TensorFlow-pipeline:

I exemplet ovan lade vi manuellt till tre värden för X_1 och X_2. Nu ska vi se hur man laddar data till TensorFlow:

Steg 1) Skapa data

Först och främst, låt oss använda numpy-biblioteket för att generera två slumpmässiga värden.

import numpy as np
x_input = np.random.sample((1,2))
print(x_input)

[[0.8835775 0.23766977]]

Steg 2) Skapa platshållaren

Liksom i föregående exempel skapar vi en platshållare med namnet X. Vi måste ange formen på tensorn explicit. I fallet kommer vi att ladda en array med endast två värden. Vi kan skriva formen som form=[1,2]

# using a placeholder
x = tf.placeholder(tf.float32, shape=[1,2], name = 'X')

Steg 3) Definiera datasetmetoden

Därefter måste vi definiera datamängden där vi kan fylla i värdet på platshållaren x. Vi måste använda metoden tf.data.Dataset.from_tensor_slices

dataset = tf.data.Dataset.from_tensor_slices(x)

Steg 4) Skapa pipeline

I steg fyra måste vi initiera pipeline där data ska flöda. Vi måste skapa en iterator med make_initializable_iterator. Vi kallar den iterator. Sedan måste vi anropa den här iteratorn för att mata nästa batch data, get_next. Vi namnger det här steget get_next. Observera att i vårt exempel finns det bara en batch data med bara två värden.

iterator = dataset.make_initializable_iterator() 
get_next = iterator.get_next()

Steg 5) Utför operationen

Det sista steget liknar det föregående exemplet. Vi initierar en session och kör operationsiteratorn. Vi matar feed_dict med värdet som genereras av numpy. Dessa två värden kommer att fylla platshållaren x. Sedan kör vi get_next för att skriva ut resultatet.

with tf.Session() as sess:
    # feed the placeholder with data
    sess.run(iterator.initializer, feed_dict={ x: x_input }) 
    print(sess.run(get_next))

[0.8835775  0.23766978]

TensorFlow 1.x vs TensorFlow 2.x: Vad som ändrades

TensorFlow 2.0 var en banbrytande omskrivning av det användarvänliga API:et. Att förstå skillnaden är viktigt, eftersom en stor mängd handledningskod online, inklusive exemplen ovan, riktar sig mot 1.x-stilen.

Multiplikationsexemplet, omskrivet. Tre steg och en session blir en rad, eftersom operationen körs i samma ögonblick som den anropas:

import tensorflow as tf

X_1 = tf.constant([1, 2, 3], dtype=tf.float32)
X_2 = tf.constant([4, 5, 6], dtype=tf.float32)

result = tf.multiply(X_1, X_2, name="multiply")
print(result.numpy())        # [ 4. 10. 18.]

Inmatningspipelinen, omskriven. Ingen platshållare och inget iteratorobjekt krävs:

import numpy as np
import tensorflow as tf

x_input = np.random.sample((1, 2))
dataset = tf.data.Dataset.from_tensor_slices(x_input)

for batch in dataset:
    print(batch.numpy())

Om du behöver hastigheten på en kompilerad graf, linda in funktionen i @tf.function och TensorFlow trackonverterar det automatiskt till ett. Legacy 1.x-skript kan också köras oförändrade genom namnrymden tf.compat.v1, men den sökvägen är endast för underhåll och bör inte användas för nytt arbete.

TensorFlow: Viktiga slutsatser och Code Hänvisning

• TensorFlow betyder: TensorFlow är det mest kända biblioteket för djupinlärning de senaste åren. En utövare som använder TensorFlow kan bygga vilken djupinlärningsstruktur som helst, som CNN, RNN eller enkla artificiella neurala nätverk.
• TensorFlow används mestadels av akademiker, startups och stora företag. Google använder TensorFlow i nästan alla Google dagliga produkter inklusive Gmail, Foto och Google Sökmotor.
• Ocuco-landskapet Google Brain team utvecklade TensorFlow för att minska klyftan mellan forskare och produktutvecklare. År 2015 gjorde de TensorFlow offentligt; det växer snabbt i popularitet. Numera är TensorFlow det djupinlärningsbibliotek med flest repositories på GitHub.
• Utövare använder TensorFlow eftersom det enkelt kan distribueras i stor skala, i molnet, i webbläsaren eller på mobila enheter som kör iOS och Android.

TensorFlow arbetar i en session. Varje session definieras av en graf med olika beräkningar. Ett enkelt exempel kan vara att multiplicera med ett tal. I TensorFlow krävs tre steg:

1. Definiera variabeln

X_1 = tf.placeholder(tf.float32, name = "X_1")
X_2 = tf.placeholder(tf.float32, name = "X_2")

2. Definiera beräkningen

multiply = tf.multiply(X_1, X_2, name = "multiply")

3. Utför operationen

with tf.Session() as session:
    result = session.run(multiply, feed_dict={X_1: [1, 2, 3], X_2: [4, 5, 6]})
    print(result)

En vanlig metod i TensorFlow är att skapa en pipeline för att ladda data. Om du följer dessa fem steg kommer du att kunna ladda data till TensorFLow:

1. Skapa data

import numpy as np
x_input = np.random.sample((1,2))
print(x_input)

2. Skapa platshållaren

x = tf.placeholder(tf.float32, shape=[1,2], name = 'X')

3. Definiera datasetmetoden

dataset = tf.data.Dataset.from_tensor_slices(x)

4. Skapa pipeline

iterator = dataset.make_initializable_iterator()
get_next = iterator.get_next()

5. Kör programmet

with tf.Session() as sess:
    sess.run(iterator.initializer, feed_dict={x: x_input})
    print(sess.run(get_next))

Vanliga frågor