Hva er TensorFlow? Hvordan det fungerer Architecture & funksjoner

Hva er TensorFlow?

tensorflow er en åpen kildekode ende-til-ende-plattform for å lage maskinlæringsapplikasjoner. Det er et symbolsk matematikkbibliotek som bruker dataflyt og differensierbar programmering for å utføre ulike oppgaver fokusert på trening og slutninger om dype nevrale nettverk. Det lar utviklere lage maskinlæringsapplikasjoner ved å bruke ulike verktøy, biblioteker og fellesskapsressurser.

For tiden er det mest berømte biblioteket for dyp læring i verden GoogleTensorFlow. Google bruker maskinlæring på tvers av produktene sine for å forbedre søk, oversettelse, bildeteksting og anbefalinger.

TensorFlow eksempel

For å gi et konkret eksempel, Google Brukere kan oppleve en raskere og mer raffinert søkeopplevelse med AI. Hvis brukeren skriver inn et nøkkelord i søkefeltet, Google gir et forslag til hva som kan være det neste ordet.

Google ønsker å bruke maskinlæring for å dra nytte av sine enorme datasett for å gi brukerne den beste opplevelsen. Tre forskjellige grupper bruker maskinlæring:

• Forskere
• Dataforskere
• programmerere

De kan alle bruke det samme verktøysettet for å samarbeide med hverandre og forbedre effektiviteten.

Google inneholder ikke bare store datasett, men kjører også enorm datainfrastruktur, så TensorFlow ble bygget for å skalere fra starten av. TensorFlow er et bibliotek utviklet av Google Brain Team skal akselerere maskinlæring og forskning på dype nevrale nettverk.

Den ble bygget for å kjøre på flere CPUer eller GPUer og til og med mobile operativsystemer, og den har flere wrappers på flere språk som Python, C++ or Java.

Historien til TensorFlow

For et par år siden begynte dyp læring å utkonkurrere alle andre maskinlæringsalgoritmer når de leverte en enorm mengde data. Google så at den kunne bruke disse dype nevrale nettverkene til å forbedre tjenestene sine:

• Gmail
• Bilde
• Google søkemotor

De bygde et rammeverk som heter tensorflow slik at forskere og utviklere kunne jobbe med den samme modellen, og deretter distribuere den i en skala mange kunne bruke.

TensorFlow ble offentliggjort i november 2015, og versjon 1.0 fulgte i februar 2017. Den langt større endringen kom med TensorFlow 2.0 i september 2019, som gjorde ivrig utførelse til standard og tok i bruk Keras som standard API på høyt nivå. Fra versjon 2.16 og utover er Keras 3 standard, og den samme modellkoden kan også kjøres på JAX eller Py.Torch-backends.

TensorFlow er utgitt under Apache 2.0-lisensen, så du kan bruke, endre og distribuere den, inkludert kommersielt, uten å betale. Google.

Hvordan TensorFlow fungerer

TensorFlow lar deg bygge dataflytgrafer og -strukturer for å definere hvordan data beveger seg gjennom en graf ved å ta inndata som en flerdimensjonal matrise kalt Tensor. Den lar deg konstruere et flytskjema over operasjoner som kan utføres på disse inngangene, som går i den ene enden og kommer i den andre enden som utgang.

tensorflow Architecture

TensorFlow-arkitekturen fungerer i tre deler:

• Forbehandling av data
• Bygg modellen
• Trene og anslå modellen

Det kalles TensorFlow fordi det tar input som en flerdimensjonal matrise, også kjent som tensorer. Du kan konstruere en slags flytskjema av operasjoner (kalt en graf) som du vil utføre på den inngangen. Inngangen går inn i den ene enden, og deretter flyter den gjennom dette systemet med flere operasjoner og kommer ut i den andre enden som utgang.

Hvor kan TensorFlow kjøre?

TensorFlows maskinvare- og programvarekrav faller inn i to faser:

Utviklingsfase: dette er når du trener modellen, vanligvis på en stasjonær eller bærbar PC.

Kjørings- eller inferensfaseNår opplæringen er fullført, kan modellen kjøres på mange plattformer:

• Desktop kjører Windows, macOS eller Linux
• Cloud som en webtjeneste
• Mobile enheter som iOS og Android

Du kan trene den på flere maskiner, så kan du kjøre den på en annen maskin, når du har den trente modellen.

Modellen kan trenes og brukes på GPU-er så vel som CPU-er. GPU-er ble opprinnelig designet for videospill. Rundt 2009 viste Stanford-forskere at GPU-er er ekstremt effektive i matrise- og lineær algebraoperasjoner som nevrale nettverk er avhengige av. Dyp læring er avhengig av mye matrisemultiplikasjon. TensorFlow er veldig rask til å beregne matrisemultiplikasjonen fordi den er skrevet i C++. Selv om det er implementert i C++, TensorFlow kan nås og kontrolleres av andre språk hovedsakelig, Python.

En annen viktig funksjon er TensorBoard, som visualiserer grafen, treningsmålingene og fordelingen av vekter mens modellen kjører.

TensorFlow-komponenter

tensor

TensorFlows navn er direkte avledet fra kjernerammeverket: tensorI TensorFlow involverer alle beregningene tensorer. En tensor er en vektor or matrise av n-dimensjoner som representerer alle typer data. Alle verdier i en tensor har identisk datatype med en kjent (eller delvis kjent) forme. Formen på dataene er dimensjonaliteten til matrisen eller matrisen.

En tensor kan stamme fra inngangsdataene eller resultatet av en beregning. I TensorFlow utføres alle operasjonene inne i en graf. Grafen er et sett med beregninger som finner sted suksessivt. Hver operasjon kalles en op node og er knyttet til hverandre.

Grafen skisserer operasjonene og forbindelsene mellom nodene. Den viser imidlertid ikke verdiene. Kanten på nodene er tensoren, dvs. en måte å fylle operasjonen med data.

grafer

TensorFlow bruker et graframmeverk. Grafen samler og beskriver alle serieberegningene som er gjort under treningen. Grafen har mange fordeler:

• Den kjører på flere CPU-er eller GPU-er, og til og med på mobile operativsystemer
• Portabiliteten til grafen gjør det mulig å bevare beregningene for umiddelbar eller senere bruk. Grafen kan lagres for å bli utført i fremtiden.
• Alle beregningene i grafen gjøres ved å koble tensorer sammen
  • En graf har noder og kanter. Hver node bærer en matematisk operasjon og produserer en utgang, mens kantene beskriver forholdet mellom inngangs- og utganger mellom nodene. Tensorene beveger seg langs kantene.

Hvorfor er TensorFlow populær?

TensorFlow er bredt tatt i bruk fordi det er tilgjengelig på alle ekspertisenivåer. API-ene dekker alt fra en trelinjers Keras-modell til et håndbygd CNN eller RNN. Fordi beregning uttrykkes som en graf, kan TensorBoard visualisere nettverket og gjøre feilsøking mye enklere. Det distribueres også i stor skala, kjører på CPU, GPU og TPU, og på mobil gjennom TensorFlow Lite.

TensorFlow er fortsatt et av de to mest brukte rammeverkene for dyp læring på GitHub, sammen med Py.Torch.

tensorflow Algorithms

TensorFlow leveres med høynivåestimatorer for flere klassiske algoritmer. I TensorFlow 1.x lå disse under tf.estimator:

• Lineær regresjon: tf.estimator.LinearRegressor
• Klassifisering: tf.estimator.LinearClassifier
• Klassifisering av dyp læring: tf.estimator.DNNClassifier
• Bred og dyp læring: tf.estimator.DNNLinearCombinedClassifier
• Forsterket treregresjon: tf.estimator.BoostedTreesRegressor
• Forsterket treklassifisering: tf.estimator.BoostedTreesClassifier

TensorFlow vs. PyTorch: Hvilken bør du velge?

TensorFlow og PyTorch er de to dominerende rammeverkene for dyp læring, og de praktiske forskjellene har blitt betydelig mindre siden TensorFlow 2.0 tok i bruk ivrig utførelse.

Det pragmatiske svaret: velg TensorFlow når modellen må sendes til mobil, nettleseren eller en administrert serveringsstabel, og velg PyTorch når du itererer på modellarkitektur. Keras 3, standarden fra TensorFlow 2.16 og utover, myker opp beslutningen ytterligere, fordi den samme Keras-koden kan kjøres på en TensorFlow-, JAX- eller Py-server.Torch-backend.

Hvordan beregninger fungerer i TensorFlow

import numpy as np
import tensorflow as tf

I de to første kodelinjene har vi importert tensorflow som tf. Med Python, er det en vanlig praksis å bruke et kort navn for et bibliotek. Fordelen er å unngå å skrive inn hele navnet på biblioteket når vi skal bruke det. For eksempel kan vi importere tensorflow som tf, og kalle tf når vi vil bruke en tensorflow-funksjon

La oss øve på den grunnleggende arbeidsflyten til TensorFlow med enkle TensorFlow-eksempler. La oss lage en beregningsgraf som multipliserer to tall sammen.

I eksemplet vil vi multiplisere X_1 og X_2 sammen. TensorFlow vil opprette en node for å koble operasjonen. I vårt eksempel kalles det multiplikasjon. Når grafen er bestemt, vil TensorFlow-beregningsmotorer multiplisere X_1 og X_2 sammen.

Til slutt vil vi kjøre en TensorFlow-økt som vil kjøre beregningsgrafen med verdiene X_1 og X_2 og skrive ut resultatet av multiplikasjonen.

La oss definere inngangsnodene X_1 og X_2. Når vi oppretter en node i TensorFlow, må vi velge hva slags node vi skal opprette. Nodene X1 og X2 vil være en plassholdernode. Plassholderen tilordner en ny verdi hver gang vi foretar en beregning. Vi oppretter dem som en TF dot-plassholdernode.

Trinn 1: Definer variabelen

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

En plassholder trenger en datatype. Dette er tall, så tf.float32 er det riktige valget. Navneargumentet er valgfritt, men nyttig, fordi det er etiketten som vises i TensorBoard-visualiseringen av grafen. X_2 er definert på samme måte.

Trinn 2: Definer beregningen

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

Nå kan vi definere noden som utfører multiplikasjonsoperasjonen. I TensorFlow kan vi gjøre det ved å opprette en tf.multiply-node.

Vi vil sende inn X_1- og X_2-nodene til multiplikasjonsnoden. Det forteller tensorflow å koble disse nodene i beregningsgrafen, så vi ber den trekke verdiene fra x og y og multiplisere resultatet. La oss også gi multiplikasjonsnoden navnet multiplikasjon. Det er hele definisjonen for vår enkle beregningsgraf.

Trinn 3: Utfør operasjonen

For å utføre operasjoner i grafen må vi opprette en sesjon. I TensorFlow gjøres det med tf.Session(). Nå som vi har en sesjon, kan vi be sesjonen om å kjøre operasjoner på beregningsgrafen vår ved å kalle session. For å kjøre beregningen må vi bruke run.

Når multiplikasjonsoperasjonen kjører, trenger den verdiene til nodene X_1 og X_2, så du mater dem inn under kjøring. Vi kan gjøre det ved å oppgi en parameter kalt feed_dict. Vi sender verdien 1,2,3 for X_1 og 4,5,6 for X_2.

Vi skriver ut resultatene med print(result). Vi bør 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.]

Alternativer for å laste data inn i TensorFlow

Det første trinnet før trening a maskin læring algoritme er å laste inn dataene. Det finnes to vanlige måter å laste inn data på:

1. Last inn data i minnetDet er den enkleste metoden. Du laster inn alle dataene dine i minnet som én enkelt matrise. Du skriver vanlig Python for dette; ingenting av det er TensorFlow-spesifikt.

2. TensorFlow-datapipelineTensorFlow tilbyr et innebygd API som laster inn dataene, bruker transformasjoner og mater modellen. Denne metoden fungerer veldig bra, spesielt når du har et stort datasett. For eksempel er bildeposter kjent for å være enorme og ikke få plass i minnet. Datapipelinen administrerer minnet på egenhånd.

Hvilken løsning skal man bruke?

Last inn data i minnet

Hvis datasettet ditt ikke er for stort, dvs. mindre enn 10 gigabyte, kan du bruke den første metoden. Dataene kan passe inn i minnet. Du kan bruke et kjent bibliotek kalt Pandas til å importere CSV-filer. Du vil lære mer om pandaer i den neste opplæringen.

Last inn data med TensorFlow-pipelinen

Den andre metoden fungerer best hvis du har et stort datasett. For eksempel, hvis du har et datasett på 50 gigabyte, og datamaskinen har bare 16 gigabyte minne, vil maskinen krasje.

I denne situasjonen må du bygge en TensorFlow-pipeline. Pipelinen vil laste inn dataene i batcher, eller små deler. Hver batch vil bli sendt til pipelinen og være klar for trening. Å bygge en pipeline er en utmerket løsning fordi den lar deg bruke parallell databehandling. Det betyr at TensorFlow vil trene modellen på tvers av flere CPU-er. Det øker hastigheten på beregningen og gjør det praktisk å trene større nettverk.

Kort sagt: last inn små datasett i minnet med pandaer, og bruk en TensorFlow-pipeline når dataene er store eller når du ønsker parallell lasting på tvers av flere CPU-er.

Hvordan lage TensorFlow Pipeline

Her er trinnene for å lage en TensorFlow-rørledning:

I eksemplet ovenfor la vi manuelt til tre verdier for X_1 og X_2. Nå skal vi se hvordan vi laster inn data til TensorFlow:

Trinn 1) Opprett dataene

Først av alt, la oss bruke numpy-biblioteket til å generere to tilfeldige verdier.

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

[[0.8835775 0.23766977]]

Trinn 2) Opprett plassholderen

Som i forrige eksempel lager vi en plassholder med navnet X. Vi må spesifisere formen på tensoren eksplisitt. I tilfelle vil vi laste en matrise med bare to verdier. Vi kan skrive formen som form=[1,2]

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

Trinn 3) Definer datasettmetoden

Deretter må vi definere datasettet der vi kan fylle ut verdien av plassholderen x. Vi må bruke metoden tf.data.Dataset.from_tensor_slices

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

Trinn 4) Lag rørledningen

I trinn fire må vi initialisere rørledningen der dataene skal flyte. Vi må lage en iterator med make_initializable_iterator. Vi kaller den iterator. Da må vi kalle denne iteratoren for å mate neste batch med data, get_next. Vi kaller dette trinnet get_next. Legg merke til at i vårt eksempel er det bare én batch med data med bare to verdier.

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

Trinn 5) Utfør operasjonen

Det siste trinnet ligner på forrige eksempel. Vi starter en økt, og vi kjører operasjonsiteratoren. Vi mater feed_dict med verdien generert av følelsesløs. Disse to verdiene vil fylle plassholderen x. Deretter kjører vi get_next for å skrive 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: Hva endret seg

TensorFlow 2.0 var en banebrytende omskriving av det brukervendte API-et. Det er viktig å forstå forskjellen, fordi en stor mengde veiledningskode på nettet, inkludert eksemplene ovenfor, er rettet mot 1.x-stilen.

Multiplikasjonseksemplet, omskrevet. Tre trinn og en økt blir én linje, fordi operasjonen utføres i det øyeblikket den kalles:

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

Inndata-pipelinen, omskrevet. Ingen plassholder og intet iteratorobjekt er nødvendig:

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 trenger hastigheten til en kompilert graf, pakk inn funksjonen i @tf.function og TensorFlow tracgjør det om til ett automatisk. Eldre 1.x-skript kan også kjøres uendret gjennom navnerommet tf.compat.v1, men den banen er kun for vedlikehold og bør ikke brukes til nytt arbeid.

TensorFlow: Viktige konklusjoner og Code Referanse

• TensorFlow betyr: tensorflow er det mest kjente dyplæringsbiblioteket de siste årene. En utøver som bruker TensorFlow kan bygge hvilken som helst dyp læringsstruktur, som CNN, RNN eller enkle kunstige nevrale nettverk.
• TensorFlow brukes mest av akademikere, oppstartsbedrifter og store selskaper. Google bruker TensorFlow i nesten alt Google dagligvarer, inkludert Gmail, Foto og Google Søkemotor.
• Ocuco Google Hjerneteamet utviklet TensorFlow for å tette gapet mellom forskere og produktutviklere. I 2015 offentliggjorde de TensorFlow; det vokser raskt i popularitet. I dag er TensorFlow det dyplæringsbiblioteket med flest repositorier på GitHub.
• Utøvere bruker TensorFlow fordi det er enkelt å distribuere i stor skala, i skyen, i nettleseren eller på mobile enheter som kjører iOS og Android.

TensorFlow fungerer i en økt. Hver økt er definert av en graf med forskjellige beregninger. Et enkelt eksempel kan være å multiplisere med et tall. I TensorFlow kreves tre trinn:

1. Definer variabelen

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. Utfør operasjonen

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 praksis i TensorFlow er å opprette en pipeline for å laste inn dataene. Hvis du følger disse fem trinnene, vil du kunne laste inn data til TensorFLow:

1. Lag dataene

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

2. Opprett plassholderen

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

3. Definer datasettmetoden

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

4. Lag rørledningen

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

5. Kjør programmet

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

Spørsmål og svar