Hvad er TensorFlow? Hvordan fungerer det? Architecture & funktioner

Hvad er TensorFlow?

TensorFlow er en open source end-to-end platform til at skabe Machine Learning-applikationer. Det er et symbolsk matematikbibliotek, der bruger dataflow og differentierbar programmering til at udføre forskellige opgaver fokuseret på træning og inferens af dybe neurale netværk. Det giver udviklere mulighed for at skabe maskinlæringsapplikationer ved hjælp af forskellige værktøjer, biblioteker og fællesskabsressourcer.

I øjeblikket er det mest berømte deep learning-bibliotek i verden Google's TensorFlow. Google anvender maskinlæring på tværs af sine produkter for at forbedre søgning, oversættelse, billedtekster og anbefalinger.

TensorFlow eksempel

For at give et konkret eksempel, Google Brugere kan opleve en hurtigere og mere raffineret søgeoplevelse med AI. Hvis brugeren skriver et søgeord i søgefeltet, Google giver en anbefaling om, hvad det næste ord kunne være.

Google ønsker at bruge maskinlæring til at udnytte deres massive datasæt og give brugerne den bedste oplevelse. Tre forskellige grupper bruger maskinlæring:

• Forskere
• Datavidenskabsfolk
• Programmører

De kan alle bruge det samme værktøjssæt til at samarbejde med hinanden og forbedre deres effektivitet.

Google indeholder ikke kun store datasæt, men kører også en enorm computerinfrastruktur, så TensorFlow blev bygget til at skalere fra starten. TensorFlow er et bibliotek udviklet af Google Brain Team skal accelerere maskinlæring og forskning i dybe neurale netværk.

Det blev bygget til at køre på flere CPU'er eller GPU'er og endda mobile operativsystemer, og det har adskillige wrappers på flere sprog som f.eks. Python, C++ or Java.

Historien om TensorFlow

For et par år siden begyndte deep learning at overgå alle andre maskinlæringsalgoritmer, når de leverede en massiv mængde data. Google så, at den kunne bruge disse dybe neurale netværk til at forbedre sine tjenester:

• Gmail
• Foto
• Google søgemaskine

De byggede et rammeværk kaldet TensorFlow så forskere og udviklere kunne arbejde på den samme model og derefter implementere den i en skala, som mange mennesker kunne bruge.

TensorFlow blev udgivet offentligt i november 2015, og version 1.0 fulgte i februar 2017. Den langt større ændring kom med TensorFlow 2.0 i september 2019, hvilket gjorde ivrig udførelse til standard og indførte Keras som standard API på højt niveau. Fra version 2.16 og fremefter er Keras 3 standard, og den samme modelkode kan også køre på JAX eller PyTorch-backends.

TensorFlow er udgivet under Apache 2.0-licensen, så du må bruge, ændre og videredistribuere den, inklusive kommercielt, uden at betale. Google.

Sådan fungerer TensorFlow

TensorFlow giver dig mulighed for at bygge dataflow-grafer og -strukturer for at definere, hvordan data bevæger sig gennem en graf ved at tage input som en multi-dimensional matrix kaldet Tensor. Det giver dig mulighed for at konstruere et flowchart over operationer, der kan udføres på disse input, som går i den ene ende og kommer i den anden ende som output.

TensorFlow Architecture

TensorFlow-arkitekturen fungerer i tre dele:

• Forbehandling af data
• Byg modellen
• Træn og estimer modellen

Det kaldes TensorFlow, fordi det tager input som et flerdimensionelt array, også kendt som tensorer. Du kan konstruere en slags rutediagram af operationer (kaldet en graf), som du vil udføre på det input. Inputtet går ind i den ene ende, og så flyder det gennem dette system med flere operationer og kommer ud i den anden ende som output.

Hvor kan TensorFlow køre?

TensorFlows hardware- og softwarekrav falder i to faser:

Udviklingsfase: dette er, når du træner modellen, normalt på en stationær eller bærbar computer.

Kørsels- eller inferensfaseNår træningen er færdig, kan modellen køre på mange platforme:

• Desktop kører Windows, macOS eller Linux
• Cloud som en webservice
• Mobile enheder som iOS og Android

Du kan træne det på flere maskiner, så kan du køre det på en anden maskine, når du har den trænede model.

Modellen kan trænes og bruges på både GPU'er og CPU'er. GPU'er blev oprindeligt designet til videospil. Omkring 2009 viste Stanford-forskere, at GPU'er er ekstremt effektive til de matrix- og lineære algebraoperationer, som neurale netværk er afhængige af. Deep learning er afhængig af en stor del af matrixmultiplikationen. TensorFlow er meget hurtig til at beregne matrixmultiplikationen, fordi den er skrevet i C++. Selvom det er implementeret i C++, TensorFlow kan hovedsagelig tilgås og kontrolleres af andre sprog, Python.

En yderligere vigtig egenskab er TensorBoard, som visualiserer grafen, træningsmålingerne og fordelingen af ​​vægte, mens modellen kører.

TensorFlow-komponenter

tensor

TensorFlows navn er direkte afledt af dets kerne-framework: tensorI TensorFlow involverer alle beregninger tensorer. En tensor er en vektor or matrix af n-dimensioner, der repræsenterer alle typer data. Alle værdier i en tensor har identisk datatype med en kendt (eller delvist kendt) forme. Formen af ​​data er dimensionaliteten af ​​matrixen eller arrayet.

En tensor kan stamme fra inputdata eller resultatet af en beregning. I TensorFlow udføres alle operationer inde i en graf. Grafen er et sæt af beregninger, der finder sted successivt. Hver operation kaldes en op node og er forbundet med hinanden.

Grafen skitserer operationerne og forbindelserne mellem noderne. Den viser dog ikke værdierne. Kanten af ​​noderne er tensoren, dvs. en måde at udfylde operationen med data.

Grafer

TensorFlow gør brug af en graframme. Grafen samler og beskriver alle serieberegninger udført under træningen. Grafen har mange fordele:

• Den kører på flere CPU'er eller GPU'er, og endda på mobile operativsystemer
• Portabiliteten af ​​grafen gør det muligt at bevare beregningerne til øjeblikkelig eller senere brug. Grafen kan gemmes for at blive udført i fremtiden.
• Alle beregningerne i grafen udføres ved at forbinde tensorer sammen
  • En graf har knuder og kanter. Hver knude bærer en matematisk operation og producerer et output, mens kanterne beskriver input- og outputforholdene mellem knuderne. Tensorerne bevæger sig selv langs kanterne.

Hvorfor er TensorFlow populær?

TensorFlow er bredt anvendt, fordi det er tilgængeligt på alle ekspertiseniveauer. Dets API'er dækker alt fra en tre-linjers Keras-model til et håndbygget CNN eller RNN. Fordi beregning udtrykkes som en graf, kan TensorBoard visualisere netværket og gøre fejlfinding langt nemmere. Det kan også implementeres i stor skala, kørende på CPU, GPU og TPU, og på mobil via TensorFlow Lite.

TensorFlow er fortsat et af de to mest anvendte deep learning-frameworks på GitHub, sammen med Py.Torch.

TensorFlow Algorithms

TensorFlow leveres med højniveauestimatorer til adskillige klassiske algoritmer. I TensorFlow 1.x fungerede disse under tf.estimator:

• Lineær regression: tf.estimator.LinearRegressor
• Klassifikation: tf.estimator.LinearKlassifier
• Deep learning klassifikation: tf.estimator.DNNClassifier
• Bred og dybdegående læring: tf.estimator.DNNLinearCombinedClassifier
• Boosted tree-regression: tf.estimator.BoostedTreesRegressor
• Boosted træklassificering: tf.estimator.BoostedTreesClassifier

TensorFlow vs. PyTorch: Hvilken skal du vælge?

TensorFlow og PyTorch er de to dominerende deep learning-frameworks, og de praktiske forskelle er blevet betydeligt mindre, siden TensorFlow 2.0 indførte ivrig udførelse.

Det pragmatiske svar: vælg TensorFlow, når modellen skal sendes til mobil, browseren eller en administreret serverstak, og vælg PyTorch, når du itererer på modelarkitektur. Keras 3, standardversionen fra TensorFlow 2.16 og fremefter, bløder beslutningen yderligere op, fordi den samme Keras-kode kan køre på en TensorFlow-, JAX- eller Py-server.Torch-backend.

Sådan fungerer beregninger i TensorFlow

import numpy as np
import tensorflow as tf

I de to første kodelinjer har vi importeret tensorflow som tf. Med Python, er det almindelig praksis at bruge et kort navn til et bibliotek. Fordelen er at undgå at skrive det fulde navn på biblioteket, når vi skal bruge det. For eksempel kan vi importere tensorflow som tf og kalde tf når vi vil bruge en tensorflow-funktion

Lad os øve os på den grundlæggende arbejdsgang i TensorFlow med simple TensorFlow-eksempler. Lad os oprette en beregningsgraf, der ganger to tal sammen.

I eksemplet vil vi gange X_1 og X_2 med hinanden. TensorFlow opretter en node for at forbinde operationen. I vores eksempel kaldes det multiplikation. Når grafen er bestemt, vil TensorFlow-beregningsmotorer gange X_1 og X_2 med hinanden.

Til sidst kører vi en TensorFlow-session, der kører beregningsgrafen med værdierne X_1 og X_2 og udskriver resultatet af multiplikationen.

Lad os definere inputnoderne X_1 og X_2. Når vi opretter en node i TensorFlow, skal vi vælge, hvilken type node vi vil oprette. Noderne X1 og X2 vil være en pladsholdernode. Pladsholderen tildeler en ny værdi, hver gang vi foretager en beregning. Vi opretter dem som en TF dot-pladsholdernode.

Trin 1: Definer variablen

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

En pladsholder skal bruge en datatype. Disse er tal, så tf.float32 er det rigtige valg. Navneargumentet er valgfrit, men nyttigt, fordi det er den etiket, der vises i TensorBoard-visualiseringen af ​​grafen. X_2 er defineret på samme måde.

Trin 2: Definer beregningen

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

Nu kan vi definere den node, der udfører multiplikationsoperationen. I TensorFlow kan vi gøre det ved at oprette en tf.multiply-node.

Vi vil videregive X_1 og X_2 noderne til multiplikationsnoden. Det fortæller tensorflow at forbinde disse noder i beregningsgrafen, så vi beder den om at trække værdierne fra x og y og gange resultatet. Lad os også give multiplikationsnoden navnet multipliceret. Det er hele definitionen for vores simple beregningsgraf.

Trin 3: Udfør handlingen

For at udføre operationer i grafen skal vi oprette en session. I TensorFlow gøres det ved hjælp af tf.Session(). Nu hvor vi har en session, kan vi bede sessionen om at køre operationer på vores beregningsgraf ved at kalde session. For at køre beregningen skal vi bruge run.

Når multiplikationsoperationen kører, skal den bruge værdierne for X_1- og X_2-noderne, så du indtaster dem under kørsel. Det kan vi gøre ved at angive en parameter kaldet feed_dict. Vi sender værdien 1,2,3 for X_1 og 4,5,6 for X_2.

Vi udskriver resultaterne med print(result). Vi skulle se 4, 10 og 18 for 1×4, 2×5 og 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.]

Muligheder for at indlæse data i TensorFlow

Det første skridt før træning a maskinlæringsalgoritme er at indlæse dataene. Der er to almindelige måder at indlæse data på:

1. Indlæs data i hukommelsenDet er den enkleste metode. Du indlæser alle dine data i hukommelsen som et enkelt array. Du skriver almindeligt Python til dette; intet af det er TensorFlow-specifikt.

2. TensorFlow-datapipelineTensorFlow leverer en indbygget API, der indlæser dataene, anvender transformationer og føder modellen. Denne metode fungerer rigtig godt, især når du har et stort datasæt. For eksempel er billedposter kendt for at være enorme og ikke passe ind i hukommelsen. Datapipelinen administrerer hukommelsen selv.

Hvilken løsning skal man bruge?

Indlæs data i hukommelsen

Hvis dit datasæt ikke er for stort, dvs. mindre end 10 gigabyte, kan du bruge den første metode. Dataene kan passe ind i hukommelsen. Du kan bruge et berømt bibliotek kaldet Pandas til at importere CSV-filer. Du vil lære mere om pandaer i den næste tutorial.

Indlæs data med TensorFlow-pipeline

Den anden metode fungerer bedst, hvis du har et stort datasæt. For eksempel, hvis du har et datasæt på 50 gigabyte, og din computer kun har 16 gigabyte hukommelse, vil maskinen gå ned.

I denne situation skal du bygge en TensorFlow-pipeline. Pipelinen vil indlæse dataene i batch eller små bidder. Hver batch vil blive sendt til pipelinen og være klar til træning. At bygge en pipeline er en fremragende løsning, fordi den giver dig mulighed for at bruge parallel beregning. Det betyder, at TensorFlow vil træne modellen på tværs af flere CPU'er. Det fremskynder beregningen og gør det praktisk at træne større netværk.

Kort sagt: indlæs små datasæt i hukommelsen med pandaer, og brug en TensorFlow-pipeline, når dataene er store, eller når du ønsker parallel indlæsning på tværs af flere CPU'er.

Sådan opretter du TensorFlow Pipeline

Her er trinene til at oprette en TensorFlow-pipeline:

I det foregående eksempel tilføjede vi manuelt tre værdier for X_1 og X_2. Nu skal vi se, hvordan man indlæser data til TensorFlow:

Trin 1) Opret dataene

Først og fremmest, lad os bruge numpy-biblioteket til at generere to tilfældige værdier.

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

[[0.8835775 0.23766977]]

Trin 2) Opret pladsholderen

Ligesom i det foregående eksempel opretter vi en pladsholder med navnet X. Vi skal specificere formen på tensoren eksplicit. I tilfælde af at vi indlæser et array med kun to værdier. Vi kan skrive formen som form=[1,2]

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

Trin 3) Definer datasætmetoden

Dernæst skal vi definere datasættet, hvor vi kan udfylde værdien af ​​pladsholderen x. Vi skal bruge metoden tf.data.Dataset.from_tensor_slices

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

Trin 4) Opret pipeline

I trin fire skal vi initialisere den pipeline, hvor dataene vil flyde. Vi skal oprette en iterator med make_initializable_iterator. Vi kalder det iterator. Så er vi nødt til at kalde denne iterator for at feed den næste batch af data, get_next. Vi navngiver dette trin get_next. Bemærk, at i vores eksempel er der kun én batch af data med kun to værdier.

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

Trin 5) Udfør handlingen

Det sidste trin ligner det forrige eksempel. Vi starter en session, og vi kører operation iteratoren. Vi fodrer feed_dict med værdien genereret af bedøvet. Disse to værdier vil udfylde pladsholderen x. Så kører vi get_next for at udskrive 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: Hvad har ændret sig

TensorFlow 2.0 var en banebrydende omskrivning af den brugervendte API. Det er vigtigt at forstå forskellen, fordi en stor mængde online tutorial-kode, inklusive eksemplerne ovenfor, er rettet mod 1.x-stilen.

Multiplikationseksemplet, omskrevet. Tre trin og en session bliver til én linje, fordi operationen udføres i det øjeblik, den kaldes:

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.]

Input-pipelinen, omskrevet. Ingen pladsholder og intet iteratorobjekt er påkrævet:

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())

Hvis du har brug for hastigheden af ​​en kompileret graf, skal du pakke funktionen ind i @tf.function og TensorFlow tracomdanner det automatisk til et. Legacy 1.x-scripts kan også køres uændret gennem tf.compat.v1-navneområdet, selvom denne sti kun er til vedligeholdelse og ikke bør bruges til nyt arbejde.

TensorFlow: Vigtige konklusioner og Code Henvisning

• TensorFlow betyder: TensorFlow er det mest berømte deep learning-bibliotek de seneste år. En praktiserende læge, der bruger TensorFlow, kan bygge enhver dyb læringsstruktur, såsom CNN, RNN eller simple kunstige neurale netværk.
• TensorFlow bruges mest af akademikere, startups og store virksomheder. Google bruger TensorFlow i næsten alt Google daglige produkter, herunder Gmail, Foto og Google Søgemaskine.
• Google Brain team udviklede TensorFlow for at lukke kløften mellem forskere og produktudviklere. I 2015 offentliggjorde de TensorFlow; det vokser hurtigt i popularitet. I dag er TensorFlow det deep learning-bibliotek med flest repositories på GitHub.
• Praktikere bruger TensorFlow, fordi det nemt kan implementeres i stor skala, i skyen, i browseren eller på mobile enheder, der kører iOS og Android.

TensorFlow fungerer i en session. Hver session er defineret af en graf med forskellige beregninger. Et simpelt eksempel kan være at gange med et tal. I TensorFlow kræves der tre trin:

1. Definer variablen

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

2. Definer beregningen

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

3. Udfø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 almindelig praksis i TensorFlow er at oprette en pipeline til at indlæse dataene. Hvis du følger disse fem trin, vil du være i stand til at indlæse data til TensorFLow:

1. Opret dataene

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

2. Opret pladsholderen

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

3. Definer datasætmetoden

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

4. Opret pipeline

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

5. Udfør programmet

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

Ofte Stillede Spørgsmål