TensorFlow alapjai: Tensor, alak, típus, munkamenetek és Operatorzok
Mi az a tenzor?
A Tensorflow neve közvetlenül a központi keretrendszeréből származik: Tensor. A Tensorflow-ban minden számítás tenzorokat tartalmaz. A tenzor egy n-dimenziós vektor vagy mátrix, amely minden típusú adatot reprezentál. A tenzorban lévő összes érték azonos adattípust tartalmaz ismert (vagy részben ismert) alakkal. 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 minden művelet egy grafikonon belül történik. A grafikon a számítások sorozata, amely egymás után megy végbe. Minden műveletet műveleti csomópontnak neveznek, és egymással kapcsolódnak.
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.
A Machine Learningben a modellek a jellemzővektoroknak nevezett objektumok listáját tartalmazzák. A jellemzővektor bármilyen adattípusú lehet. A jellemzővektor általában az elsődleges bemenet a tenzor feltöltéséhez. Ezek az értékek a tenzoron keresztül egy műveleti csomópontba áramlanak, és ennek a műveletnek/számításnak az eredménye egy új tenzort hoz létre, amelyet viszont egy új műveletben használnak fel. Mindezek a műveletek megtekinthetők a grafikonon.
Tenzor ábrázolása
A TensorFlow-ban a tenzor n-dimenziós jellemzővektorok (vagyis tömb) gyűjteménye. Például, ha van egy 2×3-as mátrixunk 1 és 6 közötti értékekkel, akkor ezt írjuk:
A TensorFlow ezt a mátrixot a következőképpen ábrázolja:
[[1, 2, 3], [4, 5, 6]]
Ha létrehozunk egy háromdimenziós mátrixot 1 és 8 közötti értékekkel, akkor a következőt kapjuk:
A TensorFlow ezt a mátrixot a következőképpen ábrázolja:
[ [[1, 2], [[3, 4], [[5, 6], [[7,8] ]
Jegyzet: A tenzor ábrázolható skalárral, vagy lehet háromnál több dimenziós alakja. Csak bonyolultabb a magasabb dimenziószint megjelenítése.
A tenzor típusai
A TensorFlow-ban az összes számítás egy vagy több tenzoron megy keresztül. A tf.tensor három tulajdonságú objektum:
- Egyedi címke (név)
- Egy méret (forma)
- Egy adattípus (dtype)
A TensorFlow-val végrehajtott minden művelet egy tenzor manipulációját foglalja magában. Négy fő tenzortípust hozhat létre:
- tf.Változó
- tf.konstans
- tf.placeholder
- tf.SparseTensor
Ebből az oktatóanyagból megtudhatja, hogyan hozhat létre egy tf.constant és egy tf.Variable értéket.
Mielőtt végigmennénk az oktatóanyagon, győződjön meg róla, hogy aktiválta a conda környezetet a TensorFlow segítségével. Ezt a környezetet hello-tf-nek neveztük el.
MacOS felhasználónak:
source activate hello-tf
Minden Windows user:
activate hello-tf
Miután ezt megtette, készen áll a tensorflow importálására
# Import tf import tensorflow as tf
Hozzon létre egy n-dimenziós tenzort
Kezdje egy tenzor létrehozásával egy dimenzióval, nevezetesen egy skalárral.
Tenzor létrehozásához használhatja a tf.constant() függvényt, amint az az alábbi TensorFlow tenzor alakzatban látható:
tf.constant(value, dtype, name = "") arguments - `value`: Value of n dimension to define the tensor. Optional - `dtype`: Define the type of data: - `tf.string`: String variable - `tf.float32`: Float variable - `tf.int16`: Integer variable - "name": Name of the tensor. Optional. By default, `Const_1:0`
0 dimenzió tenzorának létrehozásához futtassa a következő kódot
## rank 0 # Default name r1 = tf.constant(1, tf.int16) print(r1)
teljesítmény
Tensor("Const:0", shape=(), dtype=int16)
# Named my_scalar r2 = tf.constant(1, tf.int16, name = "my_scalar") print(r2)
teljesítmény
Tensor("my_scalar:0", shape=(), dtype=int16)
Minden tenzor a tenzor neve mellett jelenik meg. Minden tenzorobjektum tenzorattribútumokkal van meghatározva, például egyedi címke (név), dimenzió (alakzat) és TensorFlow adattípusok (dtype).
A tenzort decimális értékekkel vagy karakterlánccal határozhatja meg az adattípus megváltoztatásával.
# Decimal r1_decimal = tf.constant(1.12345, tf.float32) print(r1_decimal) # String r1_string = tf.constant("Guru99", tf.string) print(r1_string)
teljesítmény
Tensor("Const_1:0", shape=(), dtype=float32) Tensor("Const_2:0", shape=(), dtype=string)
Az 1-es dimenzió tenzora a következőképpen hozható létre:
## Rank 1r1_vector = tf.constant([1,3,5], tf.int16) print(r1_vector) r2_boolean = tf.constant([True, True, False], tf.bool) print(r2_boolean)
teljesítmény
Tensor("Const_3:0", shape=(3,), dtype=int16) Tensor("Const_4:0", shape=(3,), dtype=bool)
Észreveheti, hogy a TensorFlow alakzat csak 1 oszlopból áll.
2 tenzordimenziós tömb létrehozásához minden sor után be kell zárnia a zárójeleket. Nézze meg a Keras Tensor alakzat példáját alább
## Rank 2 r2_matrix = tf.constant([ [1, 2], [3, 4] ],tf.int16) print(r2_matrix)
teljesítmény
Tensor("Const_5:0", shape=(2, 2), dtype=int16)
A mátrixnak 2 sora és 2 oszlopa van 1, 2, 3, 4 értékekkel.
Egy 3 dimenziós mátrix jön létre a zárójelekkel egy újabb szint hozzáadásával.
## Rank 3 r3_matrix = tf.constant([ [[1, 2], [3, 4], [5, 6]] ], tf.int16) print(r3_matrix)
teljesítmény
Tensor("Const_6:0", shape=(1, 3, 2), dtype=int16)
A mátrix úgy néz ki, mint a második kép.
Tenzor alakja
Amikor tenzort nyomtat, a TensorFlow kitalálja az alakzatot. A TensorFlow alak tulajdonsággal azonban megkaphatja a tenzor alakját.
Az alábbiakban összeállítunk egy 10 és 15 közötti számokkal kitöltött mátrixot, és ellenőrizzük az m_shape alakját
# Shape of tensor m_shape = tf.constant([ [10, 11], [12, 13], [14, 15] ] ) m_shape.shape
teljesítmény
TensorShape([Dimension(3), Dimension(2)])
A mátrix 3 sorból és 2 oszlopból áll.
A TensorFlow hasznos parancsokat tartalmaz 0-val vagy 1-gyel kitöltött vektorok vagy mátrixok létrehozására. Például, ha egy 1-D tenzort szeretne létrehozni egy meghatározott alakkal, 10-el, kitöltve 0-val, akkor az alábbi kódot futtathatja:
# Create a vector of 0 print(tf.zeros(10))
teljesítmény
Tensor("zeros:0", shape=(10,), dtype=float32)
A tulajdonság mátrixra is működik. Itt létrehoz egy 10×10-es mátrixot 1-gyel
# Create a vector of 1 print(tf.ones([10, 10]))
teljesítmény
Tensor("ones:0", shape=(10, 10), dtype=float32)
Egy adott mátrix alakját felhasználva vektort készíthet azokból. Az m_shape mátrix 3×2 méretű. Létrehozhat egy tenzort 3 sorból, amelyet a következő kóddal tölthet ki:
# Create a vector of ones with the same number of rows as m_shape print(tf.ones(m_shape.shape[0]))
teljesítmény
Tensor("ones_1:0", shape=(3,), dtype=float32)
Ha átadja az 1 értéket a zárójelbe, akkor összeállíthat egy vektort, amely megegyezik az m_shape mátrix oszlopainak számával.
# Create a vector of ones with the same number of column as m_shape print(tf.ones(m_shape.shape[1]))
teljesítmény
Tensor("ones_2:0", shape=(2,), dtype=float32)
Végül létrehozhat egy 3×2-es mátrixot csak egy mátrixból
print(tf.ones(m_shape.shape))
teljesítmény
Tensor("ones_3:0", shape=(3, 2), dtype=float32)
Az adatok típusa
A tenzor második tulajdonsága az adat típusa. Egy tenzornak egyszerre csak egy típusú adata lehet. Egy tenzornak csak egyféle adata lehet. A típust a dtype tulajdonsággal adhatja vissza.
print(m_shape.dtype)
teljesítmény
<dtype: 'int32'>
Bizonyos esetekben meg kívánja változtatni az adatok típusát. A TensorFlow-ban tf.cast módszerrel lehetséges.
Példa
Az alábbiakban egy lebegőtenzort egész számmá alakítunk az öntött módszer használatával.
# Change type of data type_float = tf.constant(3.123456789, tf.float32) type_int = tf.cast(type_float, dtype=tf.int32) print(type_float.dtype) print(type_int.dtype)
teljesítmény
<dtype: 'float32'> <dtype: 'int32'>
A TensorFlow automatikusan kiválasztja az adattípust, ha az argumentum nincs megadva a tenzor létrehozása során. A TensorFlow kitalálja, melyek a legvalószínűbb adattípusok. Például, ha átad egy szöveget, akkor kitalálja, hogy ez egy karakterlánc, és karakterláncsá alakítja.
Operátor létrehozása
Néhány hasznos TensorFlow operátor
Tudja, hogyan kell tenzort létrehozni a TensorFlow segítségével. Ideje megtanulni a matematikai műveletek végrehajtását.
A TensorFlow tartalmazza az összes alapvető műveletet. Kezdheti egy egyszerűvel. A TensorFlow módszert fogja használni egy szám négyzetének kiszámításához. Ez a művelet egyszerű, mert csak egy argumentum szükséges a tenzor felépítéséhez.
Egy szám négyzetét a tf.sqrt(x) segítségével állítjuk össze úgy, hogy x lebegő szám.
x = tf.constant([2.0], dtype = tf.float32) print(tf.sqrt(x))
teljesítmény
Tensor("Sqrt:0", shape=(1,), dtype=float32)
Jegyzet: A kimenet egy tenzor objektumot adott vissza, és nem a 2 négyzetének eredményét. A példában a tenzor definícióját nyomtatja ki, és nem a művelet tényleges kiértékelését. A következő részben megtudhatja, hogyan működik a TensorFlow a műveletek végrehajtásában.
Az alábbiakban a gyakran használt műveletek listája található. Az ötlet ugyanaz. Minden művelethez egy vagy több argumentum szükséges.
- tf.add(a, b)
- tf.substract(a, b)
- tf.multiply(a, b)
- tf.div(a, b)
- tf.pow(a, b)
- tf.exp(a)
- tf.sqrt(a)
Példa
# Add tensor_a = tf.constant([[1,2]], dtype = tf.int32) tensor_b = tf.constant([[3, 4]], dtype = tf.int32) tensor_add = tf.add(tensor_a, tensor_b)print(tensor_add)
teljesítmény
Tensor("Add:0", shape=(1, 2), dtype=int32)
Kód Magyarázat
Hozzon létre két tenzort:
- egy tenzor 1-gyel és 2-vel
- egy tenzor 3-gyel és 4-vel
Összeadja mindkét tenzort.
Közlemény: hogy mindkét tenzornak azonos alakúnak kell lennie. A két tenzoron végrehajthat szorzást.
# Multiply tensor_multiply = tf.multiply(tensor_a, tensor_b) print(tensor_multiply)
teljesítmény
Tensor("Mul:0", shape=(1, 2), dtype=int32)
Változók
Eddig csak állandó tenzorokat hoztál létre. Nem nagy haszna van. Az adatok mindig más értékekkel érkeznek, ennek rögzítésére a Variable osztályt használhatjuk. Ez egy olyan csomópontot képvisel, ahol az értékek mindig változnak.
Változó létrehozásához használhatja a tf.get_variable() metódust
tf.get_variable(name = "", values, dtype, initializer) argument - `name = ""`: Name of the variable - `values`: Dimension of the tensor - `dtype`: Type of data. Optional - `initializer`: How to initialize the tensor. Optional If initializer is specified, there is no need to include the `values` as the shape of `initializer` is used.
Például az alábbi kód egy kétdimenziós változót hoz létre két véletlenszerű értékkel. Alapértelmezés szerint a TensorFlow véletlenszerű értéket ad vissza. Elnevezed a változót var
# Create a Variable ## Create 2 Randomized values var = tf.get_variable("var", [1, 2]) print(var.shape)
teljesítmény
(1, 2)
A második példában egy sorból és két oszlopból álló változót hoz létre. A változó dimenziójának létrehozásához az [1,2]-t kell használni
Ennek a tenzornak a kezdőértéke nulla. Például egy modell betanításakor rendelkeznie kell kezdeti értékekkel a jellemzők súlyának kiszámításához. Az alábbiakban ezeket a kezdeti értékeket nullára állítja.
var_init_1 = tf.get_variable("var_init_1", [1, 2], dtype=tf.int32, initializer=tf.zeros_initializer) print(var_init_1.shape)
teljesítmény
(1, 2)
Egy állandó tenzor értékeit átadhatja egy változóban. Létrehoz egy konstans tenzort a tf.constant() metódussal. Ezzel a tenzorral inicializálja a változót.
A változó első értéke 10, 20, 30 és 40. Az új tenzor alakja 2×2 lesz.
# Create a 2x2 matrixtensor_const = tf.constant([[10, 20], [30, 40]]) # Initialize the first value of the tensor equals to tensor_const var_init_2 = tf.get_variable("var_init_2", dtype=tf.int32, initializer=tensor_const) print(var_init_2.shape)
teljesítmény
(2, 2)
Placeholder
A helyőrző célja a tenzor táplálása. A helyőrző a tenzorokon belüli adatáramlás inicializálására szolgál. Helyőrző megadásához a feed_dict metódust kell használnia. A helyőrző csak egy munkameneten belül jelenik meg.
A következő példában látni fogja, hogyan lehet helyőrzőt létrehozni a tf.placeholder metódussal. A következő munkamenetben megtanulod, hogyan kell beadni egy helyőrzőt tényleges tenzorértékkel.
A szintaxis:
tf.placeholder(dtype,shape=None,name=None ) arguments: - `dtype`: Type of data - `shape`: dimension of the placeholder. Optional. By default, shape of the data - `name`: Name of the placeholder. Optional data_placeholder_a = tf.placeholder(tf.float32, name = "data_placeholder_a") print(data_placeholder_a)
teljesítmény
Tensor("data_placeholder_a:0", dtype=float32)
Ülés
A TensorFlow 3 fő összetevő körül működik:
- Grafikon
- tenzor
- Ülés
alkatrészek | Leírás |
---|---|
Grafikon | A grafikon alapvető fontosságú a TensorFlow-ban. Az összes matematikai műveletet (ops) egy gráfon belül hajtják végre. Elképzelhet egy grafikont egy projektként, ahol minden művelet megtörténik. A csomópontok képviselik ezeket a műveleteket, képesek elnyelni vagy új tenzorokat létrehozni. |
tenzor | A tenzor a műveletek között haladó adatokat jelöli. Korábban láthatta, hogyan kell inicializálni egy tenzort. Az állandó és a változó közötti különbség az, hogy egy változó kezdeti értéke idővel változik. |
Ülés | A munkamenet végrehajtja a műveletet a grafikonból. Ahhoz, hogy a grafikont tenzor értékekkel táplálja, meg kell nyitnia egy munkamenetet. A munkameneten belül egy operátort kell futtatnia a kimenet létrehozásához. |
A grafikonok és a munkamenetek függetlenek. Futtathat egy munkamenetet, és az értékeket később felhasználhatja a további számításokhoz.
Az alábbi példában a következőket fogja tenni:
- Hozzon létre két tenzort
- Hozzon létre egy műveletet
- Nyisson meg egy munkamenetet
- Nyomtassa ki az eredményt
Step 1) Létrehozol két x és y tenzort
## Create, run and evaluate a session x = tf.constant([2]) y = tf.constant([4])
Step 2) Az operátort x és y szorzásával hozza létre
## Create operator multiply = tf.multiply(x, y)
Step 3) Megnyit egy munkamenetet. Minden számítás a munkameneten belül fog megtörténni. Ha végzett, be kell zárnia a munkamenetet.
## Create a session to run the code sess = tf.Session()result_1 = sess.run(multiply) print(result_1) sess.close()
teljesítmény
[8]
Kód magyarázata
- tf.Session(): Munkamenet megnyitása. Az összes művelet a munkameneteken belül történik
- run(multiply): a 2. lépésben létrehozott művelet végrehajtása.
- print(eredmény_1): Végül kinyomtathatja az eredményt
- close(): A munkamenet bezárása
Az eredmény 8-at mutat, ami x és y szorzata.
A munkamenet létrehozásának másik módja egy blokkon belül. Előnye, hogy automatikusan bezárja a munkamenetet.
with tf.Session() as sess: result_2 = multiply.eval() print(result_2)
teljesítmény
[8]
A munkamenet kontextusában az eval() metódust használhatja a művelet végrehajtásához. Ez egyenértékű a run(). Olvashatóbbá teszi a kódot.
Létrehozhat egy munkamenetet, és megtekintheti az eddig létrehozott tenzorokon belüli értékeket.
## Check the tensors created before sess = tf.Session() print(sess.run(r1)) print(sess.run(r2_matrix)) print(sess.run(r3_matrix))
teljesítmény
1 [[1 2] [3 4]] [[[1 2] [3 4] [5 6]]]
A változók alapértelmezés szerint üresek, még a tenzor létrehozása után is. A változót inicializálnia kell, ha használni kívánja a változót. A tf.global_variables_initializer() objektumot meg kell hívni egy változó értékeinek inicializálásához. Ez az objektum explicit módon inicializálja az összes változót. Ez hasznos a modell betanítása előtt.
Ellenőrizheti a korábban létrehozott változók értékeit. Vegye figyelembe, hogy a tenzor kiértékeléséhez a futtatást kell használnia
sess.run(tf.global_variables_initializer()) print(sess.run(var)) print(sess.run(var_init_1)) print(sess.run(var_init_2))
teljesítmény
[[-0.05356491 0.75867283]] [[0 0]] [[10 20] [30 40]]
Használhatja a korábban létrehozott helyőrzőt, és tényleges értékkel táplálhatja be. Az adatokat át kell adnia a feed_dict metódusnak.
Például a helyőrző adatok_helyőrző_a 2-es erejét fogja használni.
import numpy as np power_a = tf.pow(data_placeholder_a, 2) with tf.Session() as sess: data = np.random.rand(1, 10) print(sess.run(power_a, feed_dict={data_placeholder_a: data})) # Will succeed.
Kód Magyarázat
- import numpy as np: Import zsibbadt könyvtár az adatok létrehozásához
- tf.pow(data_placeholder_a, 2): A műveletek létrehozása
- np.random.rand(1, 10): Véletlenszerű adattömb létrehozása
- feed_dict={data_placeholder_a: data}: Táplálja a helyőrzőt adatokkal
teljesítmény
[[0.05478134 0.27213147 0.8803037 0.0398424 0.21172127 0.01444725 0.02584014 0.3763949 0.66022706 0.7565559 ]]
Grafikon
A TensorFlow a művelet végrehajtásának zseniális megközelítésétől függ. Minden számítás egy adatfolyam-sémával van ábrázolva. Az adatfolyam-grafikont úgy fejlesztették ki, hogy az egyes műveletek közötti adatfüggőségeket lássa. A matematikai képlet vagy algoritmus számos egymást követő műveletből áll. A grafikon kényelmes módja annak, hogy megjelenítse a számítások koordinációját.
A grafikonon a csomópont és egy él. A csomópont egy művelet reprezentációja, azaz a számítási egység. Az él a tenzor, ez képes új tenzort előállítani, vagy felhasználni a bemeneti adatokat. Ez az egyes műveletek közötti függőségektől függ.
A gráf szerkezete összekapcsolja a műveleteket (azaz a csomópontokat), és hogy ezek hogyan működnek, a feed. Megjegyzendő, hogy a grafikon nem a műveletek kimenetét jeleníti meg, csak az egyes műveletek közötti kapcsolat megjelenítését segíti.
Lássunk egy példát.
Képzelje el, hogy a következő függvényt szeretné kiértékelni:
A TensorFlow létrehoz egy grafikont a függvény végrehajtásához. A grafikon így néz ki:
Könnyen láthatja az utat, amelyen a tenzorok eljutnak a végső célig.
Például láthatja, hogy az add művelet nem hajtható végre és előtt. A grafikon azt magyarázza, hogy:
- kiszámítja és:
- add 1) együtt
- add hozzá a 2-hez)
- add 3) -hoz
x = tf.get_variable("x", dtype=tf.int32, initializer=tf.constant([5])) z = tf.get_variable("z", dtype=tf.int32, initializer=tf.constant([6])) c = tf.constant([5], name = "constant")square = tf.constant([2], name = "square") f = tf.multiply(x, z) + tf.pow(x, square) + z + c
Kód Magyarázat
- x: Inicializálja az x nevű változót, amelynek állandó értéke 5
- z: Inicializáljon egy z nevű változót, amelynek állandó értéke 6
- c: Inicializálja a c nevű konstans tenzort, amelynek állandó értéke 5
- négyzet: inicializáljon egy négyzetnek nevezett konstans tenzort, amelynek állandó értéke 2
- f: Szerkessze meg az operátort
Ebben a példában úgy döntünk, hogy a változók értékeit rögzítettük. Létrehoztunk egy c nevű konstans tenzort is, amely az f függvény konstans paramétere. 5-ös fix értéket vesz fel. A grafikonon ez a paraméter a konstans tenzorban látható.
Konstans tenzort is szerkesztettünk a tf.pow( operátorban lévő hatványra). Nem szükséges. Azért csináltuk, hogy a grafikonon lássa a tenzor nevét. Ez a négyzetnek nevezett kör.
A grafikonból megértheti, hogy mi fog történni a tenzorokkal, és hogyan tud visszaadni a 66-os kimenetet.
Az alábbi kód kiértékeli a függvényt egy munkamenetben.
init = tf.global_variables_initializer() # prepare to initialize all variables with tf.Session() as sess: init.run() # Initialize x and y function_result = f.eval() print(function_result)
teljesítmény
[66]
Összegzésként
TensorFlow körül működik:
- Grafikon: A műveleteket és tenzorokat tartalmazó számítási környezet
- Tenzorok: A grafikonon folyó adatot (vagy értéket) jelöli. Ez a grafikon éle
- Sessions: A műveletek végrehajtásának engedélyezése
Hozzon létre egy állandó tenzort
állandó | tárgy |
---|---|
D0 | tf.constant(1, tf.int16) |
D1 | tf.constant([1,3,5], tf.int16) |
D2 | tf.constant([ [1, 2], [3, 4] ],tf.int16) |
D3 | tf.constant([ [[1, 2], [3, 4], [5, 6]] ], tf.int16) |
Hozzon létre egy operátort
Hozzon létre egy operátort | tárgy |
---|---|
a + b | tf.add(a, b) |
a*b | tf.multiply(a, b) |
Hozzon létre egy változó tenzort
Hozzon létre egy változót | tárgy |
---|---|
randomizált érték | tf.get_variable("var", [1, 2]) |
inicializált első érték | tf.get_variable("var_init_2", dtype=tf.int32, inicializáló=[ [1, 2], [3, 4] ]) |
Nyisson meg egy munkamenetet
Ülés | tárgy |
---|---|
Hozzon létre egy munkamenetet | tf.Session() |
Futtasson egy munkamenetet | tf.Session.run() |
Értékeljen egy tenzort | változó_neve.eval() |
Zárjon be egy munkamenetet | sess.close() |
Munkamenet blokkonként | a tf.Session()-val mint sess: |