Mi a TensorFlow? Hogyan működik? Archiszerkezet és jellemzők

Mi az a TensorFlow?

TensorFlow egy nyílt forráskódú, teljes körű platform gépi tanulási alkalmazások létrehozására. Ez egy szimbolikus matematikai könyvtár, amely adatfolyamot és differenciálható programozást használ a mély neurális hálózatok betanítására és következtetéseire összpontosító különféle feladatok végrehajtására. Lehetővé teszi a fejlesztők számára, hogy gépi tanulási alkalmazásokat hozzanak létre különféle eszközök, könyvtárak és közösségi erőforrások segítségével.

Jelenleg a világ leghíresebb mélytanulási könyvtára a következő: GoogleA TensorFlow-ja. Google gépi tanulást alkalmaz termékeiben a keresés, a fordítás, a képaláírások és az ajánlások fejlesztése érdekében.

TensorFlow példa

Hogy egy konkrét példát mondjak, Google A felhasználók gyorsabb és kifinomultabb keresési élményt tapasztalhatnak a mesterséges intelligencia segítségével. Ha a felhasználó beír egy kulcsszót a keresősávba, Google javaslatot tesz arra vonatkozóan, hogy mi lehet a következő szó.

Google gépi tanulást szeretne használni, hogy kihasználja a hatalmas adathalmazait, és a legjobb felhasználói élményt nyújtsa. Három különböző csoport használ gépi tanulást:

• Kutatók
• Adattudósok
• programozók

Mindannyian ugyanazt az eszközkészletet használhatják az együttműködéshez és hatékonyságuk javításához.

Google nemcsak nagy adathalmazokat tárol, hanem hatalmas számítási infrastruktúrát is futtat, így a TensorFlow-t kezdettől fogva skálázhatóra tervezték. A TensorFlow egy olyan könyvtár, amelyet a Google A Brain Team felgyorsítja a gépi tanulást és a mély neurális hálózatok kutatását.

Úgy tervezték, hogy több CPU-n vagy GPU-n, sőt mobil operációs rendszeren is futhasson, és számos burkolója van több nyelven, mint pl. Python, C++ or Java.

A TensorFlow története

Néhány évvel ezelőtt a mélytanulás elkezdte felülmúlni az összes többi gépi tanulási algoritmust, amikor hatalmas mennyiségű adatot adott meg. Google látta, hogy ezeket a mély neurális hálózatokat felhasználhatja szolgáltatásai fejlesztésére:

• Gmail
• Fénykép
• Google kereső

Készítettek egy keretrendszert, az úgynevezett TensorFlow hogy a kutatók és a fejlesztők ugyanazon a modellen dolgozhassanak, majd olyan méretben telepíthessék, amelyet sokan használhatnak.

A TensorFlow 2015 novemberében jelent meg nyilvánosan, az 1.0-s verzió pedig 2017 februárjában következett. A sokkal nagyobb változás a következővel történt: TensorFlow 2.0 2019 szeptemberében, amely az easy végrehajtást tette alapértelmezetté, és a Keras-t fogadta el szabványos magas szintű API-ként. A 2.16-os verziótól kezdve a Keras 3 az alapértelmezett, és ugyanaz a modellkód JAX-on vagy Py-on is futtatható.Torch háttérprogramok.

A TensorFlow az Apache 2.0 licenc alatt érhető el, így azt fizetés nélkül használhatja, módosíthatja és terjesztheti, beleértve a kereskedelmi célú felhasználást is. Google.

Hogyan működik a TensorFlow

A TensorFlow lehetővé teszi adatfolyam-gráfok és struktúrák felépítését az adatok grafikonon való áthaladásának meghatározásához, a bemeneteket Tensor nevű többdimenziós tömbként veszi fel. Lehetővé teszi az ezeken a bemeneteken végrehajtható műveletek folyamatábrájának felépítését, amely az egyik végén, a másik végén pedig kimenetként érkezik.

TensorFlow Architectúra

A TensorFlow architektúra három részből áll:

• Az adatok előfeldolgozása
• Építsd meg a modellt
• Tanítsa meg és becsülje meg a modellt

TensorFlow-nak hívják, mert többdimenziós tömbként fogadja a bemenetet, más néven tenzorok. Építhetsz egy fajta folyamatábra műveletek (úgynevezett gráf), amelyeket az adott bemeneten szeretne végrehajtani. A bemenet az egyik végén bemegy, majd átfolyik ezen a több műveletből álló rendszeren, a másik végén pedig kimenetként jön ki.

Hol futtatható a TensorFlow?

A TensorFlow hardver- és szoftverkövetelményei két fázisba sorolhatók:

Fejlesztési szakasz: ekkor tanítod be a modellt, általában asztali számítógépen vagy laptopon.

Futtatási vagy következtetési fázis: a betanítás befejezése után a modell számos platformon futtatható:

• Asztali futás Windows, macOS vagy Linux
• A felhő, mint webszolgáltatás
• Mobileszközök, mint az iOS és Android

Megtaníthatja több gépen, majd futtathatja egy másik gépen, ha megvan a betanított modell.

A modell GPU-kon és CPU-kon is tanítható és használható. A GPU-kat eredetileg videojátékokhoz tervezték. 2009 körül a Stanford kutatói kimutatták, hogy a GPU-k rendkívül hatékonyak a mátrix- és lineáris algebrai műveletekben, amelyektől a neurális hálózatok függenek. A mélytanulás sok mátrixszorzásra támaszkodik. A TensorFlow nagyon gyorsan kiszámítja a mátrixszorzást, mivel nyelven van írva. C++. Bár ben van megvalósítva C++, A TensorFlow főként más nyelveken érhető el és vezérelhető, Python.

Egy további jelentős jellemzője, hogy TensorBoard, amely a modell futása közben vizualizálja a grafikont, a betanítási metrikák és a súlyok eloszlását.

TensorFlow komponensek

tenzor

A TensorFlow neve közvetlenül a magkeretrendszeréből származik: tenzorA TensorFlow-ban minden számítás tenzorokat használ. A tenzor egy vektor or mátrix n-dimenziós, amely minden adattípust reprezentál. A tenzorban lévő összes érték azonos adattípust tartalmaz egy ismert (vagy részben ismert) adattípussal formálják. Az adatok alakja a mátrix vagy tömb dimenziója.

A tenzor származhat a bemeneti adatokból vagy egy számítás eredményéből. A TensorFlow-ban az összes műveletet a grafikon. A grafikon a számítások sorozata, amely egymás után megy végbe. Minden műveletet an op csomópont és kapcsolódnak egymáshoz.

A grafikon felvázolja a műveleteket és a csomópontok közötti kapcsolatokat. Az értékeket azonban nem jeleníti meg. A csomópontok éle a tenzor, azaz a művelet adatokkal való feltöltésének módja.

grafikonok

A TensorFlow egy gráf keretrendszert használ. A grafikon összegyűjti és leírja a képzés során elvégzett összes sorozatszámítást. A grafikonnak számos előnye van:

• Több CPU-n vagy GPU-n fut, sőt mobil operációs rendszereken is
• A grafikon hordozhatósága lehetővé teszi a számítások megőrzését azonnali vagy későbbi használatra. A grafikon elmenthető a jövőbeni végrehajtáshoz.
• A grafikonon szereplő összes számítás a tenzorok összekapcsolásával történik
  • Egy gráf csomópontokból és élekből áll. Minden csomópont egy matematikai műveletet hajt végre és egy kimenetet állít elő, míg az élek a csomópontok közötti bemeneti és kimeneti kapcsolatokat írják le. Maguk a tenzorok az élek mentén haladnak.

Miért népszerű a TensorFlow?

A TensorFlow széles körben elterjedt, mivel minden szakértelem szintjén elérhető. API-jai mindent lefednek a háromsoros Keras modelltől a kézzel készített CNN-ig vagy RNN-ig. Mivel a számítás gráfként fejezhető ki, a TensorBoard képes vizualizálni a hálózatot, és sokkal könnyebbé teszi a hibakeresést. Nagy léptékben is telepíthető, CPU-n, GPU-n és TPU-n futtatható, valamint mobilon is futtatható a TensorFlow Lite segítségével.

A TensorFlow továbbra is a két leggyakrabban használt mélytanulási keretrendszer egyike a GitHubon, a Py mellett.Torch.

TensorFlow Algorithms

A TensorFlow számos klasszikus algoritmushoz magas szintű becslőket tartalmaz. A TensorFlow 1.x-ben ezek a tf.estimator alatt voltak:

• Lineáris regresszió: tf.estimator.LinearRegressor
• Osztályozás: tf.estimator.LinearClassifier
• Mélytanulási osztályozás: tf.estimator.DNNClassifier
• Széleskörű és mély tanulás: tf.estimator.DNNLinearCombinedClassifier
• Fokozott fa regresszió: tf.estimator.BoostedTreesRegressor
• Boosted fa osztályozás: tf.estimator.BoostedTreesClassifier

TensorFlow vs. PyTorch: Melyiket válasszam?

TensorFlow és PyTorA ch a két domináns mélytanulási keretrendszer, és a gyakorlati különbségek jelentősen csökkentek, mióta a TensorFlow 2.0 átvette a lelkes végrehajtást.

A pragmatikus válasz: válaszd a TensorFlow-t, ha a modellnek mobilra, böngészőbe vagy egy felügyelt kiszolgálóveremre kell megjelennie, és válaszd a Py-t.Torch, amikor a modellarchitektúrán iterálsz. A Keras 3, a TensorFlow 2.16-os verziójától kezdődő alapértelmezett, tovább lágyítja a döntést, mivel ugyanaz a Keras kód futtatható TensorFlow, JAX vagy Py architektúrán is.Torch háttérrendszer.

Hogyan működnek a számítások a TensorFlow-ban

import numpy as np
import tensorflow as tf

A kód első két sorában a tensorflow-t tf-ként importáltuk. Val vel Python, általános gyakorlat a könyvtár rövid elnevezése. Ennek az az előnye, hogy ne írjuk be a könyvtár teljes nevét, amikor használnunk kell. Például importálhatjuk a tensorflow-t tf-ként, és meghívhatjuk a tf-et, ha tensorflow függvényt akarunk használni.

Gyakoroljuk a TensorFlow alapvető munkafolyamatát egyszerű TensorFlow példákkal. Készítsünk egy számítási gráfot, amely két számot szoroz össze.

A példában X_1-et és X_2-t fogjuk összeszorozni. A TensorFlow egy csomópontot hoz létre a művelet összekapcsolására. Példánkban ezt szorzásnak nevezzük. Amikor a gráf meghatározásra került, a TensorFlow számítási motorjai összeszorozzák X_1-et és X_2-t.

Végül lefuttatunk egy TensorFlow munkamenetet, amely lefuttatja a számítási gráfot az X_1 és X_2 értékekkel, és kinyomtatja a szorzás eredményét.

Definiáljuk az X_1 és X_2 bemeneti csomópontokat. Amikor létrehozunk egy csomópontot a TensorFlow-ban, ki kell választanunk, hogy milyen típusú csomópontot hozzunk létre. Az X1 és X2 csomópontok helyőrző csomópontok lesznek. A helyőrző minden számításnál új értéket rendel hozzá. TF pont helyőrző csomópontként fogjuk létrehozni őket.

1. lépés: Határozza meg a változót

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

A helyőrzőnek adattípusra van szüksége. Ezek számok, tehát a tf.float32 a megfelelő választás. A név argumentum opcionális, de hasznos, mert ez a címke jelenik meg a gráf TensorBoard vizualizációjában. Az X_2 ugyanígy van definiálva.

2. lépés: Határozza meg a számítást

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

Most már definiálhatjuk a szorzási műveletet végző csomópontot. A TensorFlow-ban ezt egy tf.multiply csomópont létrehozásával tehetjük meg.

Az X_1 és X_2 csomópontokat átadjuk a szorzócsomópontnak. Azt mondja a tensorflow-nak, hogy kapcsolja össze ezeket a csomópontokat a számítási gráfban, ezért megkérjük, hogy vegye ki az értékeket x-ből és y-ből, és szorozza meg az eredményt. Adjuk meg a szorzó csomópontnak a szorzás nevet is. Ez az egyszerű számítási gráfunk teljes definíciója.

3. lépés: Hajtsa végre a műveletet

A gráfon belüli műveletek végrehajtásához létre kell hoznunk egy munkamenetet (session). A TensorFlow-ban ezt a tf.Session() végzi el. Most, hogy van egy munkamenetünk, a session meghívásával kérhetjük meg a munkamenetet, hogy műveleteket futtasson a számítási gráfunkon. A számítás futtatásához a run függvényt kell használnunk.

Amikor a szorzási művelet fut, szüksége van az X_1 és X_2 csomópontok értékeire, ezért futási időben kell betáplálni ezeket. Ezt egy feed_dict nevű paraméter megadásával tehetjük meg. Az X_1 esetében az 1,2,3, az X_2 esetében pedig a 4,5,6 értékeket adjuk át.

Az eredményeket a print(result) funkcióval nyomtatjuk ki. 4, 10 és 18-at kell látnunk az 1×4, 2×5 és 3×6 esetén

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

Lehetőségek az adatok TensorFlow-ba való betöltésére

Az edzés előtti első lépés a gépi tanulási algoritmus az adatok betöltése. Az adatok betöltésének két gyakori módja van:

1. Adatok betöltése a memóriábaEz a legegyszerűbb módszer. Az összes adatot egyetlen tömbként töltöd be a memóriába. Egyszerűen írsz Python erre; egyik sem TensorFlow-specifikus.

2. TensorFlow adatfolyamatA TensorFlow beépített API-t biztosít, amely betölti az adatokat, transzformációkat alkalmaz, és táplálja a modellt. Ez a módszer nagyon jól működik, különösen akkor, ha nagy adathalmazról van szó. Például a képrekordokról köztudott, hogy hatalmasak, és nem férnek el a memóriában. Az adatfolyamat maga kezeli a memóriát.

Milyen megoldást érdemes használni?

Adatok betöltése a memóriába

Ha az adatkészlet nem túl nagy, azaz kevesebb, mint 10 gigabájt, akkor az első módszert használhatja. Az adatok elférnek a memóriában. CSV-fájlok importálásához használhatja a Pandas nevű híres könyvtárat. A következő oktatóanyagból többet megtudhat a pandákról.

Adatok betöltése TensorFlow folyamattal

A második módszer akkor működik a legjobban, ha nagy adatkészlettel rendelkezik. Például, ha egy 50 gigabájtnyi adatkészlettel rendelkezik, és a számítógépének csak 16 gigabájt memóriája van, akkor a gép összeomlik.

Ebben a helyzetben TensorFlow pipeline-t kell építeni. A pipeline kötegekben, vagyis kis chunkokban tölti be az adatokat. Minden egyes köteg bekerül a pipeline-ba, és készen áll a betanításra. A pipeline kiépítése kiváló megoldás, mert lehetővé teszi a párhuzamos számítástechnika használatát. Ez azt jelenti, hogy a TensorFlow több CPU-n keresztül tanítja be a modellt. Ez felgyorsítja a számítást, és praktikussá teszi a nagyobb hálózatok betanítását.

Röviden: tölts be kis adathalmazokat a memóriába pandákkal, és használj TensorFlow folyamatot, ha nagy az adatmennyiség, vagy ha párhuzamos betöltést szeretnél több CPU-n.

Hogyan készítsünk TensorFlow csővezetéket

Íme a TensorFlow-folyamat létrehozásának lépései:

Az előző példában manuálisan adtunk hozzá három értéket az X_1 és X_2 értékekhez. Most megnézzük, hogyan tölthetünk be adatokat a TensorFlow-ba:

1. lépés) Hozza létre az adatokat

Először is használjuk a numpy könyvtárat két véletlenszerű érték generálására.

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

[[0.8835775 0.23766977]]

2. lépés) Hozza létre a helyőrzőt

Az előző példához hasonlóan létrehozunk egy helyőrzőt X néven. Explicit módon meg kell adnunk a tenzor alakját. Abban az esetben, ha egy tömböt csak két értékkel töltünk be. Az alakzatot a következőképpen írhatjuk fel: shape=[1,2]

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

3. lépés) Határozza meg az adatkészlet módszerét

Ezután meg kell határoznunk az adatkészletet, ahol feltölthetjük az x helyőrző értékét. A tf.data.Dataset.from_tensor_slices metódust kell használnunk

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

4. lépés) Hozza létre a csővezetéket

A negyedik lépésben inicializálnunk kell a folyamatot, ahol az adatok folyni fognak. Létre kell hoznunk egy iterátort a make_initializable_iterator paraméterrel. Nevezzük iterátornak. Ezután meg kell hívnunk ezt az iterátort, hogy betápláljuk a következő adatköteget, a get_next. Ennek a lépésnek a get_next nevet adjuk. Vegye figyelembe, hogy példánkban csak egy adatköteg van, csak két értékkel.

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

5. lépés) Hajtsa végre a műveletet

Az utolsó lépés hasonló az előző példához. Elindítunk egy munkamenetet, és futtatjuk a műveletiterátort. A feed_dict-et a generált értékkel tápláljuk számtalan. Ez a két érték tölti fel az x helyőrzőt. Ezután a get_next futtatásával kinyomtatjuk az eredményt.

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: Mi változott?

A TensorFlow 2.0 a felhasználóoldali API áttörést jelentő újraértelmezése volt. A különbség megértése azért fontos, mert az online oktatóanyagok nagy része, beleértve a fenti példákat is, az 1.x stílust célozza meg.

A szorzási példa, átírva. Három lépés és egy munkamenet egyetlen sorrá válik, mivel a művelet a meghívásának pillanatában végrehajtódik:

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

A bemeneti folyamat, újraírva. Nincs szükség helyőrzőre és iterátor objektumra:

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

Ha egy lefordított gráf sebességére van szükséged, csomagold be a függvényt @tf.function és TensorFlow közé. tracautomatikusan eggyé konvertálja. A korábbi 1.x szkriptek változatlanul is futtathatók a tf.compat.v1 névtéren keresztül, bár ez az elérési út csak karbantartási célokat szolgál, és nem szabad új munkákhoz használni.

TensorFlow: Főbb tanulságok és Code Referencia

• TensorFlow jelentése: TensorFlow az utóbbi évek leghíresebb mélytanulási könyvtára. A TensorFlow-t használó gyakorló bármilyen mély tanulási struktúrát fel tud építeni, például CNN-t, RNN-t vagy egyszerű mesterséges neurális hálózatot.
• A TensorFlow-t főként akadémikusok, startupok és nagyvállalatok használják. Google szinte mindenben TensorFlow-t használ Google napi termékek, beleértve Gmail, Fotó és Google Keresőmotor.
• Az Google A Brain csapata a TensorFlow-t azért fejlesztette ki, hogy áthidalja a kutatók és a termékfejlesztők közötti szakadékot. 2015-ben nyilvánossá tették a TensorFlow-ot; népszerűsége gyorsan növekszik. Napjainkban a TensorFlow a GitHubon található legtöbb repozitóriummal rendelkező mélytanulási könyvtár.
• A szakemberek azért használják a TensorFlow-t, mert könnyen telepíthető nagy léptékben, a felhőben, a böngészőben vagy iOS-t futtató mobileszközökön. Android.

A TensorFlow egy munkamenetben működik. Minden munkamenetet egy gráf definiál, amely különböző számításokat tartalmaz. Egy egyszerű példa erre a számmal való szorzás. A TensorFlow-ban három lépés szükséges:

1. Határozza meg a változót

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

2. Határozza meg a számítást

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

3. Hajtsa végre a műveletet

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

A TensorFlow egyik gyakori gyakorlata egy folyamat létrehozása az adatok betöltéséhez. Ha követi ezt az öt lépést, akkor adatokat tölthet be a TensorFLow-ba:

1. Hozza létre az adatokat

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

2. Hozza létre a helyőrzőt

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

3. Határozza meg az adatkészlet módszerét

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

4. Hozza létre a csővezetéket

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

5. Végezze el a programot

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

GYIK