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 gegevensstroom en differentieerbare programmering gebruikt om verschillende taken uit te voeren die zijn gericht op het trainen en afleiden van diepe neurale netwerken. Het stelt ontwikkelaars in staat om machine learning-applicaties te maken met behulp van verschillende tools, bibliotheken en communitybronnen.
Momenteel is Google's TensorFlow de beroemdste deep learning-bibliotheek ter wereld. Het Google-product gebruikt machine learning in al zijn producten om de zoekmachine, vertaling, bijschriften van afbeeldingen of aanbevelingen te verbeteren.
Om een concreet voorbeeld te geven: Google-gebruikers kunnen de zoekopdracht met AI sneller en verfijnder ervaren. Als de gebruiker een trefwoord in de zoekbalk typt, geeft Google een aanbeveling over wat het volgende woord zou kunnen zijn.
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 heeft niet zomaar gegevens; ze hebben 's werelds grootste computer, dus Tensor Flow is op schaal gebouwd. TensorFlow is een bibliotheek die is ontwikkeld door het Google Brain Team om machine learning en diepgaand neuraal netwerkonderzoek 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 ++ of Java.
In deze TensorFlow-tutorial leer je
- Wat is TensorFlow?
- Geschiedenis van TensorFlow
- Hoe TensorFlow werkt
- TensorFlow-architectuur
- Waar kan Tensorflow rennen?
- Inleiding tot componenten van TensorFlow
- Waarom is TensorFlow populair?
- Lijst met prominente algoritmen die worden ondersteund door TensorFlow
- Eenvoudig TensorFlow-voorbeeld
- Opties om gegevens in TensorFlow te laden
- Maak een Tensorflow-pijplijn
Geschiedenis van TensorFlow
Een paar jaar geleden begon deep learning beter te presteren dan alle andere machine learning-algoritmen bij het verstrekken 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 Tensorflow om onderzoekers en ontwikkelaars samen te laten werken aan een AI-model. Eenmaal ontwikkeld en geschaald, kunnen veel mensen het gebruiken.
Het werd voor het eerst openbaar gemaakt eind 2015, terwijl de eerste stabiele versie verscheen in 2017. Het is open source onder Apache Open Source-licentie. U kunt het gebruiken, wijzigen en de gewijzigde versie tegen betaling opnieuw distribueren zonder iets aan Google te betalen.
Vervolgens zullen we in deze TensorFlow Deep Learning-zelfstudie leren over TensorFlow-architectuur en hoe TensorFlow werkt.
Hoe TensorFlow werkt
Met TensorFlow kunt u gegevensstroomgrafieken en -structuren maken 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 maken van bewerkingen die op deze ingangen kunnen worden uitgevoerd, die aan de ene kant en aan de andere kant als uitvoer komt.
TensorFlow-architectuur
Tensorflow-architectuur werkt in drie delen:
- Voorverwerking 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 tensoren genoemd . U kunt een soort stroomschema van bewerkingen maken (een grafiek genoemd) die u op die invoer wilt uitvoeren. De invoer gaat aan het ene uiteinde naar binnen en stroomt vervolgens door dit systeem van meerdere bewerkingen en komt aan de andere kant uit als uitvoer.
Dit is waarom het TensorFlow wordt genoemd omdat de tensor erin gaat, het door een lijst met bewerkingen stroomt en dan aan de andere kant naar buiten komt.
Waar kan Tensorflow rennen?
De hardware- en softwarevereisten van TensorFlow kunnen worden ingedeeld in
Ontwikkelingsfase: dit is wanneer je de modus traint. De training wordt meestal gedaan op uw desktop of laptop.
Run Phase of Inference Phase: Zodra de training is voltooid, kan Tensorflow op veel verschillende platforms worden uitgevoerd. U kunt het uitvoeren
- Desktop met Windows, macOS of Linux
- Cloud als webservice
- Mobiele apparaten zoals iOS en Android
Je kunt het op meerdere machines trainen en je kunt het op een andere machine laten draaien, als je eenmaal het getrainde model hebt.
Het model kan zowel op GPU's als op CPU's worden getraind en gebruikt. GPU's zijn in eerste instantie 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 het is geschreven in C ++. Hoewel het is geïmplementeerd in C ++, kan TensorFlow worden benaderd en beheerd door voornamelijk andere talen, Python.
Ten slotte is een belangrijk kenmerk van TensorFlow het TensorBoard. Het TensorBoard maakt het mogelijk om grafisch en visueel te volgen wat TensorFlow doet.
Inleiding tot componenten van TensorFlow
Tensor
De naam van Tensorflow is rechtstreeks afgeleid van het kernraamwerk: Tensor . In Tensorflow worden bij alle berekeningen tensoren gebruikt. Een tensor is een vector of matrix van n-dimensies die alle soorten gegevens vertegenwoordigt. 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 ontstaan uit de invoergegevens of het resultaat van een berekening. In TensorFlow worden alle bewerkingen in een grafiek uitgevoerd . De grafiek is een reeks berekeningen die achtereenvolgens plaatsvindt. Elke bewerking wordt een op-node genoemd en is met elkaar verbonden.
De grafiek schetst de operaties en verbindingen tussen de knooppunten. De waarden worden echter niet weergegeven. De rand van de knooppunten is de tensor, dwz een manier om de bewerking met gegevens te vullen.
Grafieken
TensorFlow maakt gebruik van een grafiekraamwerk. De grafiek verzamelt en beschrijft alle serieberekeningen die tijdens de training zijn gedaan. De grafiek heeft veel voordelen:
- Het is 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 te bewaren voor onmiddellijk 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 knoop en een rand. Het knooppunt voert de wiskundige bewerking uit en produceert eindpuntuitvoer. De randen de randen verklaren de invoer / uitvoer-relaties tussen knooppunten.
Waarom is TensorFlow populair?
TensorFlow is de beste bibliotheek van allemaal omdat het is gebouwd om voor iedereen toegankelijk te zijn. De Tensorflow-bibliotheek bevat verschillende API's om op schaal deep learning-architectuur zoals CNN of RNN te bouwen. TensorFlow is gebaseerd op grafische berekeningen; het stelt de ontwikkelaar in staat om de constructie van het neurale netwerk met Tensorboad te visualiseren. Deze tool is handig om het programma te debuggen. Ten slotte is Tensorflow gebouwd om op schaal te worden ingezet. Het draait op CPU en GPU.
Tensorflow trekt de grootste populariteit op GitHub in vergelijking met het andere deep learning-framework.
Lijst met prominente algoritmen die worden ondersteund door TensorFlow
Hieronder vindt u de lijst met ondersteunde TensorFlow-algoritmen:
Momenteel heeft TensorFlow 1.10 een ingebouwde API voor:
- Lineaire regressie: tf.estimator.LinearRegressor
- Classificatie: tf.estimator.LinearClassifier
- Classificatie voor diep leren: tf.estimator.DNNClassifier
- Diep leren wissen en diep: tf.estimator.DNNLinearCombinedClassifier
- Booster tree regressie: tf.estimator.BoostedTreesRegressor
- Verbeterde boomclassificatie: tf.estimator.BoostedTreesClassifier
Eenvoudig TensorFlow-voorbeeld
import numpy as npimport tensorflow as tf
In de eerste twee regels code hebben we tensorflow geïmporteerd als tf. Bij Python is het gebruikelijk om een korte naam voor een bibliotheek te gebruiken. Het voordeel is dat u niet de volledige naam van de bibliotheek moet typen wanneer we deze moeten gebruiken. We kunnen bijvoorbeeld tensorflow 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 computergrafiek maken die twee getallen met elkaar vermenigvuldigt.
Tijdens het voorbeeld zullen we X_1 en X_2 samen vermenigvuldigen. Tensorflow maakt een knooppunt om de bewerking te verbinden. In ons voorbeeld wordt het vermenigvuldigen genoemd. Wanneer de grafiek is bepaald, zullen de Tensorflow-rekenmachines X_1 en X_2 samen vermenigvuldigen.
TensorFlow-voorbeeld
Ten slotte zullen we een TensorFlow-sessie uitvoeren die de rekengrafiek uitvoert met de waarden van X_1 en X_2 en het resultaat van de vermenigvuldiging afdrukken.
Laten we de invoerknooppunten X_1 en X_2 definiëren. Wanneer we een knooppunt maken in Tensorflow, moeten we kiezen wat voor soort knooppunt we willen maken. De X1- en X2-knooppunten zullen een placeholder-knooppunt zijn. De tijdelijke aanduiding kent elke keer dat we een berekening maken een nieuwe waarde toe. We zullen ze maken als een tijdelijke aanduiding voor een 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 placeholder-knooppunt maken, moeten we het gegevenstype hier getallen toevoegen, zodat we een drijvende-komma-gegevenstype 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 met de waarde X_1 door te geven 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 computergrafiek te koppelen, dus we vragen het om de waarden uit x en y te halen en het resultaat te vermenigvuldigen. Laten we ook het vermenigvuldigingsknooppunt de naam vermenigvuldigen geven. Het is de volledige definitie van onze eenvoudige computergrafiek.
Stap 3: voer de bewerking uit
Om bewerkingen in de grafiek uit te voeren, moeten we een sessie maken. In Tensorflow wordt dit gedaan door tf.Session (). Nu we een sessie hebben, kunnen we de sessie vragen om bewerkingen op onze computergrafiek uit te voeren door 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 X_1- en X_2-knooppunten moet pakken, dus we moeten ook waarden invoeren voor X_1 en X_2. We kunnen dat doen door een parameter op te geven met de naam feed_dict. We passeren de waarde 1,2,3 voor X_1 en 4,5,6 voor X_2.
We printen de resultaten met print (resultaat). We zouden 4, 10 en 18 moeten zien voor 1x4, 2x5 en 3x6
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 voordat u een machine learning-algoritme gaat trainen, is het laden van de gegevens. Er zijn twee veelgebruikte manieren om gegevens te laden:
1. Laad gegevens in het geheugen: het is de eenvoudigste methode. U laadt al uw gegevens in het geheugen als een enkele array. U kunt een Python-code schrijven. Deze regels code zijn niet gerelateerd aan Tensorflow.
2. Tensorflow-gegevenspijplijn. Tensorflow heeft een ingebouwde API die u helpt om de gegevens te laden, de bewerking uit te voeren en het machine learning-algoritme gemakkelijk te voeden. Deze methode werkt erg goed, vooral als je een grote dataset hebt. Het is bijvoorbeeld bekend dat beeldrecords enorm zijn en niet in het geheugen passen. De datapijplijn beheert het geheugen zelf
Welke oplossing te gebruiken?
Laad gegevens in het geheugen
Als uw dataset niet te groot is, dwz minder dan 10 gigabyte, kunt u de eerste methode gebruiken. De gegevens passen in het geheugen. U kunt een beroemde bibliotheek genaamd Panda's gebruiken om CSV-bestanden te importeren. In de volgende tutorial leer je meer over panda's.
Laad gegevens met de 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 aan geheugen, dan crasht de machine.
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 geduwd en is klaar voor de training. Het bouwen van een pijplijn is een uitstekende oplossing omdat u hiermee parallel computing kunt gebruiken. Dit betekent dat Tensorflow het model zal trainen over meerdere CPU's. Het bevordert de berekening en maakt het mogelijk om een krachtig neuraal netwerk te trainen.
U zult in de volgende tutorials zien hoe u een aanzienlijke pijplijn kunt bouwen om uw neurale netwerk te voeden.
Kort samengevat, 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 u wilt gebruik maken van meerdere CPU's, dan zult u comfortabeler werken met de Tensorflow-pijplijn.
Maak een Tensorflow-pijplijn
In het voorgaande voorbeeld voegen we handmatig drie waarden toe voor X_1 en X_2. Nu zullen we zien hoe we gegevens in 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 npx_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 het geval dat we een array met slechts twee waarden laden. We kunnen de vorm schrijven als vorm = [1,2]
# using a placeholderx = tf.placeholder(tf.float32, shape=[1,2], name = 'X')
Stap 3) Definieer de datasetmethode
Vervolgens moeten we de Dataset definiëren waar 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. Dan moeten we deze iterator aanroepen om de volgende batch gegevens te voeden, get_next. We noemen deze stap get_next. Merk op 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 we voeren de operatie-iterator uit. We voeden de feed_dict met de waarde gegenereerd door numpy. Deze twee waarden vullen de tijdelijke aanduiding x. Vervolgens voeren we get_next uit om het resultaat af te drukken.
with tf.Session() as sess:# feed the placeholder with datasess.run(iterator.initializer, feed_dict={ x: x_input })print(sess.run(get_next)) # output [ 0.52374458 0.71968478]
[0.8835775 0.23766978]
Overzicht
TensorFlow betekenis: TensorFlow is de meest bekende deep learning-bibliotheek van de afgelopen jaren. Een beoefenaar die TensorFlow gebruikt, kan elke diepe 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 Google-producten, waaronder Gmail, Photo en Google Search Engine.
Het Google Brain-team heeft TensorFlow ontwikkeld om de kloof tussen onderzoekers en productontwikkelaars te dichten. In 2015 maakten ze TensorFlow openbaar; het groeit snel in populariteit. TensorFlow is tegenwoordig de deep learning-bibliotheek met de meeste opslagplaatsen op GitHub.
Beoefenaars gebruiken Tensorflow omdat het eenvoudig op grote schaal kan worden ingezet. Het is gebouwd om in de cloud of op mobiele apparaten zoals iOS en Android te werken.
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:
- Definieer de variabele
X_1 = tf.placeholder(tf.float32, name = "X_1")X_2 = tf.placeholder(tf.float32, name = "X_2")
- Definieer de berekening
multiply = tf.multiply(X_1, X_2, name = "multiply")
- Voer de handeling 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 om een pijplijn te maken om de gegevens te laden. Als u deze vijf stappen volgt, kunt u gegevens naar TensorFLow laden
- Creëer de gegevens
import numpy as npx_input = np.random.sample((1,2))print(x_input)
- Maak de tijdelijke aanduiding
x = tf.placeholder(tf.float32, shape=[1,2], name = 'X')
- Definieer de datasetmethode
dataset = tf.data.Dataset.from_tensor_slices(x)
- Maak de pijplijn
iterator = dataset.make_initializable_iterator() get_next = iterator.get_next()
- Voer het programma uit
with tf.Session() as sess:sess.run(iterator.initializer, feed_dict={ x: x_input })print(sess.run(get_next))