Wat is TensorFlow? Hoe het werkt? Introductie & Architectuur

Laten we deze tutorial beginnen met de introductie van TensorFlow:

Wat is TensorFlow?

TensorFlow is een open-source end-to-end platform voor het maken van Machine Learning-applicaties. Het is een symbolische wiskundebibliotheek die dataflow en differentieerbare programmering gebruikt om verschillende taken uit te voeren die gericht zijn op training en gevolgtrekking van diepe neurale netwerken. Hiermee kunnen ontwikkelaars machine learning-applicaties maken met behulp van verschillende tools, bibliotheken en communitybronnen.

Momenteel is de bekendste deep learning-bibliotheek ter wereld TensorFlow van Google. Het Google-product maakt in al zijn producten gebruik van machine learning om de zoekmachine, vertaling, ondertiteling van afbeeldingen of aanbevelingen te verbeteren.

TensorFlow-voorbeeld

Om een ​​concreet voorbeeld te geven: Google-gebruikers kunnen met AI een snellere en verfijndere zoekervaring ervaren. Als de gebruiker een trefwoord in de zoekbalk typt, geeft Google een aanbeveling over wat het volgende woord zou kunnen zijn.

TensorFlow-voorbeeld
TensorFlow-voorbeeld

Google wil machine learning gebruiken om te profiteren van hun enorme datasets om gebruikers de beste ervaring te bieden. Drie verschillende groepen gebruiken machine learning:

  • onderzoekers
  • Datawetenschappers
  • Programmeurs

Ze kunnen allemaal dezelfde toolset gebruiken om met elkaar samen te werken en hun efficiëntie te verbeteren.

Google beschikt niet zomaar over gegevens; ze hebben de grootste computer ter wereld, dus Tensor Flow is op schaal gebouwd. TensorFlow is een bibliotheek ontwikkeld door het Google Brain Team om machine learning en diepgaand onderzoek naar neurale netwerken te versnellen.

Het is gebouwd om op meerdere CPU's of GPU's en zelfs mobiele besturingssystemen te draaien, en het heeft verschillende wrappers in verschillende talen zoals Python, C + + or Java.

Geschiedenis van TensorFlow

Een paar jaar geleden begon deep learning beter te presteren dan alle andere machine learning-algoritmen bij het opleveren van een enorme hoeveelheid gegevens. Google zag dat het deze diepe neurale netwerken kon gebruiken om zijn diensten te verbeteren:

  • Gmail
  • Foto
  • Google-zoekmachine

Ze bouwen een raamwerk genaamd tensorstroom om onderzoekers en ontwikkelaars samen te laten werken aan een AI-model. Als het eenmaal is ontwikkeld en geschaald, kunnen veel mensen het gebruiken.

Het werd eind 2015 voor het eerst openbaar gemaakt, terwijl de eerste stabiele versie in 2017 verscheen. Het is open source onder Apache Open Source-licentie. U kunt het gebruiken, aanpassen en de gewijzigde versie tegen betaling opnieuw distribueren zonder iets aan Google te betalen.

Vervolgens zullen we in deze TensorFlow Deep Learning-tutorial meer leren over TensorFlow architectuur en hoe werkt TensorFlow.

Hoe TensorFlow werkt

Met TensorFlow kunt u gegevensstroomgrafieken en -structuren bouwen om te definiëren hoe gegevens door een grafiek bewegen door invoer te nemen als een multidimensionale array genaamd Tensor. Hiermee kunt u een stroomschema samenstellen van bewerkingen die op deze invoer kunnen worden uitgevoerd, dat aan de ene kant loopt en aan de andere kant als uitvoer komt.

TensorFlow Architectuur

tensorstroom architecture werkt in drie delen:

  • Het voorbewerken van de gegevens
  • Bouw het model
  • Train en schat het model

Het wordt Tensorflow genoemd omdat het invoer nodig heeft als een multidimensionale array, ook wel bekend als tensoren. Je kunt een soort construeren flowchart aantal bewerkingen (een zogenaamde grafiek) die u op die invoer wilt uitvoeren. De input komt aan de ene kant binnen, stroomt vervolgens door dit systeem van meerdere bewerkingen en komt er aan de andere kant weer uit als output.

Dit is de reden waarom het TensorFlow wordt genoemd, omdat de tensor erin gaat, door een lijst met bewerkingen stroomt, en dan aan de andere kant weer naar buiten komt.

Waar kan Tensorflow draaien?

TensorFlow-hardware, en Softwarevereisten kan worden ingedeeld in

Ontwikkelingsfase: Dit is wanneer je de modus traint. De training vindt meestal plaats op uw desktop of laptop.

Runfase of inferentiefase: Zodra de training is voltooid, kan Tensorflow op veel verschillende platforms worden uitgevoerd. Je kunt het laten draaien

  • Bureaublad actief Windows, macOS of Linux
  • Cloud als webservice
  • Mobiele apparaten zoals iOS en Android

U kunt het op meerdere machines trainen en vervolgens op een andere machine uitvoeren, zodra u over het getrainde model beschikt.

Het model kan worden getraind en gebruikt op zowel GPU's als CPU's. GPU's zijn oorspronkelijk ontworpen voor videogames. Eind 2010 ontdekten Stanford-onderzoekers dat GPU ook erg goed was in matrixbewerkingen en algebra, zodat ze erg snel zijn voor het uitvoeren van dit soort berekeningen. Diep leren is afhankelijk van veel matrixvermenigvuldiging. TensorFlow is erg snel in het berekenen van de matrixvermenigvuldiging, omdat deze in C++ is geschreven. Hoewel het is geïmplementeerd in C++, kan TensorFlow worden benaderd en bestuurd door voornamelijk andere talen, Python.

Een belangrijk kenmerk van TensorFlow ten slotte is het TensorBoard. De TensorBoard maakt het mogelijk om grafisch en visueel te volgen wat TensorFlow doet.

TensorFlow-componenten

strekspier

De naam Tensorflow is rechtstreeks afgeleid van het kernframework: strekspier. In Tensorflow zijn bij alle berekeningen tensoren betrokken. Een tensor is een vector or Matrix van n-dimensies die alle soorten gegevens vertegenwoordigen. Alle waarden in een tensor bevatten een identiek gegevenstype met een bekende (of gedeeltelijk bekende) vorm. De vorm van de gegevens is de dimensionaliteit van de matrix of array.

Een tensor kan voortkomen uit de invoergegevens of uit het resultaat van een berekening. In TensorFlow worden alle bewerkingen uitgevoerd binnen een diagram. De grafiek is een reeks berekeningen die achtereenvolgens plaatsvinden. Elke bewerking wordt een genoemd op knooppunt en zijn met elkaar verbonden.

De grafiek schetst de activiteiten en verbindingen tussen de knooppunten. De waarden worden echter niet weergegeven. De rand van de knooppunten is de tensor, dat wil zeggen een manier om de operatie met gegevens te vullen.

Grafieken

TensorFlow maakt gebruik van een grafenframework. De grafiek verzamelt en beschrijft alle reeksberekeningen die tijdens de training zijn uitgevoerd. De grafiek heeft veel voordelen:

  • Het werd gedaan om op meerdere CPU's of GPU's en zelfs op een mobiel besturingssysteem te draaien
  • De draagbaarheid van de grafiek maakt het mogelijk om de berekeningen voor onmiddellijke of later gebruik. De grafiek kan worden opgeslagen om in de toekomst te worden uitgevoerd.
  • Alle berekeningen in de grafiek worden gedaan door tensoren met elkaar te verbinden
    • Een tensor heeft een knooppunt en een rand. Het knooppunt voert de wiskundige bewerking uit en produceert eindpuntuitvoer. De randen verklaren de invoer/uitvoer-relaties tussen knooppunten.

Waarom is TensorFlow populair?

TensorFlow is de beste bibliotheek van allemaal omdat deze is gebouwd om voor iedereen toegankelijk te zijn. De Tensorflow-bibliotheek bevat verschillende API's om op grote schaal deep learning te bouwen archizoals CNN of RNN. TensorFlow is gebaseerd op grafiekberekening; het stelt de ontwikkelaar in staat de constructie van het neurale netwerk met Tensorboad te visualiseren. Deze tool is handig bij het debuggen van het programma. Ten slotte is Tensorflow gebouwd om op schaal te worden ingezet. Het draait op CPU en GPU.

Tensorflow trekt de grootste populariteit op GitHub vergeleken met het andere deep learning-framework.

TensorFlow-algoritmen

Hieronder staan ​​de algoritmen die door TensorFlow worden ondersteund:

Momenteel heeft TensorFlow 1.10 een ingebouwde API voor:

  • Lineaire regressie: tf.estimator.LinearRegressor
  • Classificatie:tf.estimator.LinearClassifier
  • Deep learning-classificatie: tf.estimator.DNNClassifier
  • Diep leren wissen en diep: tf.estimator.DNNLinearCombinedClassifier
  • Boosterboomregressie: tf.estimator.BoostedTreesRegressor
  • Verbeterde boomclassificatie: tf.estimator.BoostedTreesClassifier

Hoe berekeningen werken in TensorFlow

import numpy as np
import tensorflow as tf

In de eerste twee regels code hebben we tensorflow geïmporteerd als tf. Met Python, is het gebruikelijk om een ​​korte naam voor een bibliotheek te gebruiken. Het voordeel is dat we voorkomen dat we de volledige naam van de bibliotheek typen wanneer we deze moeten gebruiken. We kunnen tensorflow bijvoorbeeld importeren als tf, en tf aanroepen als we een tensorflow-functie willen gebruiken

Laten we de elementaire workflow van Tensorflow oefenen met eenvoudige TensorFlow-voorbeelden. Laten we een rekengrafiek maken die twee getallen met elkaar vermenigvuldigt.

In dit voorbeeld vermenigvuldigen we X_1 en X_2 met elkaar. Tensorflow zal een knooppunt creëren om de operatie te verbinden. In ons voorbeeld heet dit vermenigvuldigen. Wanneer de grafiek is bepaald, zullen de rekenmachines van Tensorflow X_1 en X_2 met elkaar vermenigvuldigen.

Berekeningen werken in TensorFlow
TensorFlow-voorbeeld

Ten slotte zullen we een TensorFlow-sessie uitvoeren die de rekengrafiek zal uitvoeren met de waarden van X_1 en X_2 en het resultaat van de vermenigvuldiging zal afdrukken.

Laten we de invoerknooppunten X_1 en X_2 definiëren. Wanneer we een knooppunt in Tensorflow maken, moeten we kiezen welk soort knooppunt we willen maken. De X1- en X2-knooppunten zullen een plaatshouderknooppunt zijn. De tijdelijke aanduiding wijst elke keer dat we een berekening maken een nieuwe waarde toe. We zullen ze maken als een tijdelijk aanduidingsknooppunt voor de TF-punt.

Stap 1: Definieer de variabele

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

Wanneer we een plaatshouderknooppunt maken, moeten we het gegevenstype doorgeven. We zullen hier getallen toevoegen, zodat we een gegevenstype met drijvende komma kunnen gebruiken, laten we tf.float32 gebruiken. We moeten dit knooppunt ook een naam geven. Deze naam zal verschijnen als we naar de grafische visualisaties van ons model kijken. Laten we dit knooppunt X_1 noemen door een parameter met de naam naam door te geven met de waarde X_1 en laten we nu X_2 op dezelfde manier definiëren. X_2.

Stap 2: Definieer de berekening

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

Nu kunnen we het knooppunt definiëren dat de vermenigvuldigingsbewerking uitvoert. In Tensorflow kunnen we dat doen door een tf.multiply-knooppunt te maken.

We zullen de knooppunten X_1 en X_2 doorgeven aan het vermenigvuldigingsknooppunt. Het vertelt tensorflow om die knooppunten in de rekengrafiek te koppelen, dus we vragen het om de waarden uit x en y te halen en het resultaat te vermenigvuldigen. Laten we het vermenigvuldigingsknooppunt ook de naam vermenigvuldigen geven. Het is de volledige definitie voor onze eenvoudige rekengrafiek.

Stap 3: Voer de bewerking uit

Om bewerkingen in de grafiek uit te voeren, moeten we een sessie creëren. In Tensorflow wordt dit gedaan door tf.Session(). Nu we een sessie hebben, kunnen we de sessie vragen bewerkingen uit te voeren op onze rekengrafiek door de sessie aan te roepen. Om de berekening uit te voeren, moeten we run gebruiken.

Wanneer de optelbewerking wordt uitgevoerd, zal het zien dat het de waarden van de knooppunten X_1 en X_2 moet ophalen, dus we moeten ook waarden voor X_1 en X_2 invoeren. We kunnen dat doen door een parameter op te geven met de naam feed_dict. We geven de waarde 1,2,3 door voor X_1 en 4,5,6 voor X_2.

De resultaten printen we af met print(result). We zouden 4, 10 en 18 moeten zien voor 1×4, 2×5 en 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.]

Opties om gegevens in TensorFlow te laden

De eerste stap vóór het trainen van a machine learning algoritme is om de gegevens te laden. Er zijn twee gebruikelijke manieren om gegevens te laden:

1. Gegevens in het geheugen laden: Het is de eenvoudigste methode. U laadt al uw gegevens in het geheugen als één enkele array. Je kunt een Python-code schrijven. Deze coderegels hebben geen betrekking op Tensorflow.

2. Tensorflow-gegevenspijplijn: Tensorflow heeft een ingebouwde API waarmee u de gegevens eenvoudig kunt laden, de bewerking kunt uitvoeren en het machine learning-algoritme kunt voeden. Deze methode werkt erg goed, vooral als je een grote dataset hebt. Het is bijvoorbeeld bekend dat beeldregistraties enorm zijn en niet in het geheugen passen. De datapijplijn beheert het geheugen zelf

Welke oplossing gebruiken?

Gegevens in het geheugen laden

Als uw dataset niet te groot is, dat wil zeggen minder dan 10 gigabyte, kunt u de eerste methode gebruiken. De gegevens kunnen in het geheugen passen. U kunt een beroemde bibliotheek genaamd Pandas gebruiken om CSV-bestanden te importeren. In de volgende tutorial leer je meer over panda's.

Gegevens laden met Tensorflow-pijplijn

De tweede methode werkt het beste als u een grote dataset heeft. Als u bijvoorbeeld een dataset van 50 gigabyte heeft, en uw computer heeft slechts 16 gigabyte geheugen, dan zal de machine crashen.

In deze situatie moet u een Tensorflow-pijplijn bouwen. De pijplijn laadt de gegevens in batch of in een klein deel. Elke batch wordt naar de pijplijn gepusht en is klaar voor de training. Het bouwen van een pijplijn is een uitstekende oplossing omdat u hiermee parallel computergebruik kunt gebruiken. Het betekent dat Tensorflow het model over meerdere CPU's zal trainen. Het bevordert de berekening en maakt het mogelijk een krachtig neuraal netwerk te trainen.

In de volgende tutorials zul je zien hoe je een aanzienlijke pijplijn kunt bouwen om je neurale netwerk te voeden.

Kort gezegd: als u een kleine dataset heeft, kunt u de gegevens in het geheugen laden met de Pandas-bibliotheek.

Als u een grote dataset heeft en gebruik wilt maken van meerdere CPU's, dan zult u comfortabeler werken met de Tensorflow-pijplijn.

Hoe een TensorFlow-pijplijn te creëren

Hier volgen de stappen om een ​​TensorFlow-pijplijn te maken:

In het voorgaande voorbeeld hebben we handmatig drie waarden toegevoegd voor X_1 en X_2. Nu zullen we zien hoe we gegevens naar Tensorflow kunnen laden:

Stap 1) Creëer de gegevens

Laten we eerst de numpy-bibliotheek gebruiken om twee willekeurige waarden te genereren.

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

[[0.8835775 0.23766977]]

Stap 2) Maak de tijdelijke aanduiding

Net als in het vorige voorbeeld maken we een tijdelijke aanduiding met de naam X. We moeten de vorm van de tensor expliciet specificeren. In dat geval laden we een array met slechts twee waarden. We kunnen de vorm schrijven als shape=[1,2]

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

Stap 3) Definieer de datasetmethode

Vervolgens moeten we de gegevensset definiëren waarin we de waarde van de tijdelijke aanduiding x kunnen invullen. We moeten de methode tf.data.Dataset.from_tensor_slices gebruiken

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

Stap 4) Maak de pijplijn

In stap vier moeten we de pijplijn initialiseren waar de gegevens naartoe zullen stromen. We moeten een iterator maken met make_initializable_iterator. We noemen het iterator. Vervolgens moeten we deze iterator aanroepen om de volgende batch gegevens, get_next, te voeden. We noemen deze stap get_next. Houd er rekening mee dat er in ons voorbeeld slechts één batch gegevens is met slechts twee waarden.

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

Stap 5) Voer de bewerking uit

De laatste stap is vergelijkbaar met het vorige voorbeeld. We starten een sessie en voeren de bewerkingstrator uit. We voeden het feed_dict met de waarde die wordt gegenereerd door numpy. Deze twee waarden vullen de tijdelijke aanduiding x in. Vervolgens voeren we get_next uit om het resultaat af te drukken.

with tf.Session() as sess:
    # feed the placeholder with data
    sess.run(iterator.initializer, feed_dict={ x: x_input }) 
    print(sess.run(get_next)) # output [ 0.52374458  0.71968478]
[0.8835775  0.23766978]

Samengevat

  • TensorFlow-betekenis: TensorFlow is de bekendste deep learning-bibliotheek van de afgelopen jaren. Een beoefenaar die TensorFlow gebruikt, kan elke diepgaande leerstructuur bouwen, zoals CNN, RNN of een eenvoudig kunstmatig neuraal netwerk.
  • TensorFlow wordt vooral gebruikt door academici, startups en grote bedrijven. Google gebruikt TensorFlow in bijna alle dagelijkse producten van Google, waaronder Gmail, Foto en Google-zoekmachine.
  • Het team van Google Brain heeft TensorFlow ontwikkeld om de kloof tussen onderzoekers en productontwikkelaars te dichten. In 2015 maakten ze TensorFlow openbaar; het is snel growing qua populariteit. Tegenwoordig is TensorFlow de deep learning-bibliotheek met de meeste repositories op GitHub.
  • Beoefenaars gebruiken Tensorflow omdat het eenvoudig op schaal kan worden ingezet. Het is gebouwd om te werken in de cloud of op mobiele apparaten zoals iOS en Android.

Tensorflow werkt in een sessie. Elke sessie wordt gedefinieerd door een grafiek met verschillende berekeningen. Een eenvoudig voorbeeld kan zijn om te vermenigvuldigen met een getal. In Tensorflow zijn drie stappen vereist:

  1. Definieer de variabele
X_1 = tf.placeholder(tf.float32, name = "X_1")
X_2 = tf.placeholder(tf.float32, name = "X_2")
  1. Definieer de berekening
multiply = tf.multiply(X_1, X_2, name = "multiply")
  1. Voer de bewerking uit
with tf.Session() as session:
result = session.run(multiply, feed_dict={X_1:[1,2,3], X_2:[4,5,6]})
print(result)

Een veel voorkomende praktijk in Tensorflow is het maken van een pijplijn om de gegevens te laden. Als u deze vijf stappen volgt, kunt u gegevens naar TensorFLow laden:

  1. Maak de gegevens
import numpy as np
x_input = np.random.sample((1,2))
print(x_input)
  1. Maak de tijdelijke aanduiding
x = tf.placeholder(tf.float32, shape=[1,2], name = 'X')
  1. Definieer de gegevenssetmethode
dataset = tf.data.Dataset.from_tensor_slices(x)
  1. Maak de pijplijn
iterator = dataset.make_initializable_iterator() get_next = iterator.get_next()
  1. Voer het programma uit
with tf.Session() as sess:  
sess.run(iterator.initializer, feed_dict={ x: x_input })  
print(sess.run(get_next))