A TensorFlow alapjai: Tensor, Shape, Type, Session & Operátorok

Mi az a tenzor?

A Tensorflow neve közvetlenül az alapkeretről származik: a Tensor. A Tensorflow-ban az összes számítás tenzorokat tartalmaz. A tenzor egy n dimenziójú vektor vagy mátrix, amely minden típusú adatot képvisel. A tenzor összes értéke azonos (vagy részben ismert) alakú adattípust tartalmaz. Az adatok alakja a mátrix vagy tömb dimenziósága.

A tenzor származhat a bemeneti adatokból vagy a számítás eredményéből. A TensorFlow alkalmazásban az összes műveletet egy grafikonon belül hajtják végre. A grafikon egy sor számítás, amely egymást követõen történik. Mindegyik műveletet op csomópontnak hívják, és összekapcsolódnak egymással.

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

A Gépi tanulás során a modellek az objektumok listájával vannak ellátva, amelyeket funkcióvektoroknak nevezünk. A jellemző vektor bármilyen adattípusú lehet. A vonásvektor általában az elsődleges bemenet a tenzor feltöltésére. Ezek az értékek egy op csomópontba áramlanak a tenzoron keresztül, és ennek a műveletnek / számításnak az eredménye egy új tenzort hoz létre, amelyet viszont egy új műveletben fognak használni. Mindezek a műveletek megtekinthetők a grafikonon.

Ebben az oktatóanyagban megtanulhatja a TensorFlow alapjait, mint például:

• Mi az a tenzor?
• A tenzor képviselete
• A tenzor típusai
• Hozzon létre egy n-dimenziós tenzort
• A tenzor alakja
• Az adatok típusa
• Operátor létrehozása
• Néhány hasznos TensorFlow operátor
• Változók
• Helykitöltő
• Ülés
• Grafikon

A tenzor képviselete

A TensorFlow-ban a tenzor egy n-dimenziós jellemzővektor (azaz tömb) gyűjteménye. Például, ha van egy 2x3 mátrixunk, amelynek értéke 1 és 6 között van, akkor ezt írjuk:

A tenzor képviselete

A TensorFlow ezt a mátrixot képviseli:

[[1, 2, 3],[4, 5, 6]] 

Ha háromdimenziós mátrixot hozunk létre 1 és 8 közötti értékekkel, akkor:

A TensorFlow ezt a mátrixot képviseli:

[ [[1, 2],[[3, 4],[[5, 6],[[7,8] ] 

Megjegyzés: A tenzort skalárral lehet ábrázolni, vagy három dimenziónál nagyobb alakja is lehet. Csak bonyolultabb a magasabb dimenziós szint megjelenítése.

A tenzor típusai

A TensorFlow alkalmazásban az összes számítás egy vagy több tenzoron megy keresztül. A tf.tensor egy három tulajdonságú objektum:

• Egyedi címke (név)
• Egy méret (alak)
• Adattípus (dtype)

A TensorFlow alkalmazással végrehajtott minden művelet egy tenzor manipulálását jelenti. Négy fő tenzor típus hozható létre:

• tf.Változó
• tf.állandó
• tf.placeholder
• tf.SparseTensor

Ebben az oktatóanyagban megtanulhatja, hogyan hozhat létre egy tf.constant és egy tf.Variable.

Mielőtt végignéznénk az oktatóanyagot, győződjön meg arról, hogy a TensorFlow segítségével aktiválta a conda környezetet. Ezt a környezetet hello-tf-nek neveztük el.

MacOS felhasználó esetén:

source activate hello-tf 

Windows felhasználók számára:

activate hello-tf 

Miután ezt megtette, készen áll a tensorflow importálására

# Import tfimport tensorflow as tf 

Hozzon létre egy n-dimenziós tenzort

Kezdjük egy tenzor létrehozásával, amelynek egy dimenziója van, mégpedig skalár.

Tenzor létrehozásához használhatja a tf.constant () -t, amint az az alábbi TensorFlow tenzor alakformában 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` 

A 0 dimenziós tenzor létrehozásához futtassa a következő kódot

## rank 0# Default namer1 = tf.constant(1, tf.int16)print(r1)

Kimenet

Tensor("Const:0", shape=(), dtype=int16) 

# Named my_scalarr2 = tf.constant(1, tf.int16, name = "my_scalar")print(r2) 

Kimenet

Tensor("my_scalar:0", shape=(), dtype=int16) 

Minden tenzort a tenzor neve jelenít meg. Minden tenzorobjektumot tenzorattribútumokkal definiálunk, például egyedi címkével (név), dimenzióval (alakzat) és TensorFlow adattípusokkal (dtype).

Tenzort definiálhat decimális értékekkel vagy karakterlánccal az adatok típusának megváltoztatásával.

# Decimalr1_decimal = tf.constant(1.12345, tf.float32)print(r1_decimal)# Stringr1_string = tf.constant("Guru99", tf.string)print(r1_string) 

Kimenet

Tensor("Const_1:0", shape=(), dtype=float32)Tensor("Const_2:0", shape=(), dtype=string) 

Az 1. 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) 

Kimenet

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 tenzorméretű tömb létrehozásához minden sor után le kell zárni a zárójeleket. Ellenőrizze az alábbi Keras Tensor alak példát

## Rank 2r2_matrix = tf.constant([ [1, 2],[3, 4] ],tf.int16)print(r2_matrix) 

Kimenet

Tensor("Const_5:0", shape=(2, 2), dtype=int16) 

A mátrix 2 sorból és 2 oszlopból áll, amelyek értéke 1, 2, 3, 4.

A 3 dimenziós mátrixot úgy építjük fel, hogy egy újabb szintet adunk a zárójelekkel.

## Rank 3r3_matrix = tf.constant([ [[1, 2],[3, 4],[5, 6]] ], tf.int16)print(r3_matrix) 

Kimenet

Tensor("Const_6:0", shape=(1, 3, 2), dtype=int16) 

A mátrix úgy néz ki, mint a két kép.

A tenzor alakja

A tenzor nyomtatásakor a TensorFlow kitalálja az alakot. A tenzor alakját azonban a TensorFlow shape tulajdonsággal kaphatja meg.

Az alábbiakban összeállít egy mátrixot, amely 10 és 15 közötti számmal van kitöltve, és ellenőrzi az m_shape alakját

# Shape of tensorm_shape = tf.constant([ [10, 11],[12, 13],[14, 15] ])m_shape.shape 

Kimenet

TensorShape([Dimension(3), Dimension(2)]) 

A mátrix 3 sorból és 2 oszlopból áll.

A TensorFlow hasznos parancsokkal 0 vagy 1-gyel töltött vektort vagy mátrixot hozhat létre. Például, ha egy 1-D tenzort szeretne létrehozni, amelynek meghatározott alakja 10, 0-val van töltve, akkor futtathatja az alábbi kódot:

# Create a vector of 0print(tf.zeros(10)) 

Kimenet

Tensor("zeros:0", shape=(10,), dtype=float32) 

A tulajdonság mátrixhoz is működik. Itt létrehoz egy 10x10-es mátrixot, amely 1-tel van kitöltve

# Create a vector of 1print(tf.ones([10, 10])) 

Kimenet

Tensor("ones:0", shape=(10, 10), dtype=float32) 

Használhat egy adott mátrix alakját vektorok létrehozásához. Az m_shape mátrix 3x2 méretű. Hozhat létre egy tenzort 3 sorral, amelyeket a következő kóddal töltünk be:

# Create a vector of ones with the same number of rows as m_shapeprint(tf.ones(m_shape.shape[0])) 

Kimenet

Tensor("ones_1:0", shape=(3,), dtype=float32) 

Ha átadja az 1 értéket a zárójelbe, létrehozhat 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_shapeprint(tf.ones(m_shape.shape[1])) 

Kimenet

Tensor("ones_2:0", shape=(2,), dtype=float32) 

Végül létrehozhat egy 3x2 méretű mátrixot csak az egyikével

print(tf.ones(m_shape.shape)) 

Kimenet

Tensor("ones_3:0", shape=(3, 2), dtype=float32) 

Az adatok típusa

A tenzor második tulajdonsága az adattípus. A tenzornak egyszerre csak egyféle adata lehet. A tenzornak csak egy adattípusa lehet. A típust a dtype tulajdonsággal adhatja vissza.

print(m_shape.dtype) 

Kimenet

Bizonyos esetekben módosítani szeretné az adatok típusát. A TensorFlow-ban a tf.cast módszerrel lehetséges.

Példa

Az alábbiakban egy lebegő tenzort alakítunk át egész számra az öntött módszer használatával.

# Change type of datatype_float = tf.constant(3.123456789, tf.float32)type_int = tf.cast(type_float, dtype=tf.int32)print(type_float.dtype)print(type_int.dtype) 

Kimenet

A TensorFlow automatikusan kiválasztja az adatok típusát, ha az argumentum nincs megadva a tenzor létrehozása során. A TensorFlow kitalálja, hogy mi a legvalószínűbb adattípus. Például, ha átad egy szöveget, akkor kitalálja, hogy ez egy karakterlánc, és konvertálja stringgé.

Operátor létrehozása

Néhány hasznos TensorFlow operátor

Tudja, hogyan hozhat létre tenzort a TensorFlow segítségével. Itt az ideje megtanulni a matematikai műveletek végrehajtását.

A TensorFlow tartalmazza az összes alapműveletet. Kezdheti egy egyszerűvel. A TensorFlow metódust használja a szám négyzetének kiszámításához. Ez a művelet egyszerű, mert a tenzor felépítéséhez csak egy argumentum szükséges.

Egy szám négyzetét úgy alakítjuk ki, hogy a tf.sqrt (x), x-vel lebegő számként.

x = tf.constant([2.0], dtype = tf.float32)print(tf.sqrt(x)) 

Kimenet

Tensor("Sqrt:0", shape=(1,), dtype=float32) 

Megjegyzés: A kimenet egy tenzor objektumot adott vissza, és nem a 2-es négyzet eredményét adta meg. A példában a tenzor definícióját nyomtatja ki, és nem a művelet tényleges értékelését. A következő szakaszban megtudhatja, hogyan működik a TensorFlow a műveletek végrehajtásához.

Az alábbiakban felsoroljuk a gyakran használt műveleteket. Az ötlet ugyanaz. Minden művelethez egy vagy több argumentum szükséges.

• tf.add (a, b)
• tf. kivonat (a, b)
• tf. sokszor (a, b)
• tf.div (a, b)
• tf.pow (a, b)
• tf.exp (a)
• tf.sqrt (a)

Példa

# Addtensor_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) 

Kimenet

Tensor("Add:0", shape=(1, 2), dtype=int32) 

Kód Magyarázat

Hozzon létre két tenzort:

• egy tenzor 1-vel és 2-vel
• egy tenzor 3-mal és 4-vel

Összeadja mindkét tenzort.

Megjegyzés : hogy mindkét tenzornak azonos alakúnak kell lennie. Szorzást hajthat végre a két tenzor felett.

# Multiplytensor_multiply = tf.multiply(tensor_a, tensor_b)print(tensor_multiply) 

Kimenet

Tensor("Mul:0", shape=(1, 2), dtype=int32) 

Változók

Eddig csak állandó feszültségeket hoztál létre. Nem nagy hasznát veszi. Az adatok mindig más értékekkel érkeznek, ennek megragadásához használhatja a Variable osztályt. Olyan csomópontot fog képviselni, 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. OptionalIf 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 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. Megnevezi a var változót

# Create a Variable## Create 2 Randomized valuesvar = tf.get_variable("var", [1, 2])print(var.shape) 

Kimenet

(1, 2) 

A második példában létrehoz egy változót egy sorral és két oszloppal. A változó dimenziójának létrehozásához az [1,2] -et kell használnia

A tenzor kezdőértékei nulla. Például, amikor betanít egy modellt, akkor rendelkeznie kell kezdeti értékekkel a szolgáltatások 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) 

Kimenet

(1, 2) 

Átviheti az állandó tenzor értékeit egy változóban. Létrehoz egy állandó tenzort a tf.constant () módszerrel. Ezt a tenzort használja a változó inicializálásához.

A változó első értéke 10, 20, 30 és 40. Az új tenzor alakja 2x2 lesz.

# Create a 2x2 matrixtensor_const = tf.constant([[10, 20],[30, 40]])# Initialize the first value of the tensor equals to tensor_constvar_init_2 = tf.get_variable("var_init_2", dtype=tf.int32, initializer=tensor_const)print(var_init_2.shape) 

Kimenet

(2, 2) 

Helykitöltő

A helyőrző célja a tenzor táplálása. A helyőrző az adatok inicializálására szolgál, hogy a tenzorokban áramoljanak. Helyőrző megadásához a feed_dict metódust kell használnia. A helyőrző csak munkameneten belül kerül betáplálásra.

A következő példában megtudhatja, hogyan hozhat létre helyőrzőt a tf.placeholder módszerrel. A következő munkamenetben megtanulja, hogyan kell betenni a helyőrzőt tényleges tenzorértékkel.

A szintaxis a következő:

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. Optionaldata_placeholder_a = tf.placeholder(tf.float32, name = "data_placeholder_a")print(data_placeholder_a) 

Kimenet

Tensor("data_placeholder_a:0", dtype=float32) 

Ülés

A TensorFlow 3 fő komponens körül működik:

• Grafikon
• Tenzor
• Ülés

Alkatrészek	Leírás
Grafikon	A grafikon alapvető a TensorFlow-ban. Az összes matematikai műveletet (op) egy grafikonon belül hajtják végre. Elképzelheti, hogy egy grafikon projektként minden műveletet elvégez. A csomópontok ezeket az opciókat képviselik, képesek új tenzorokat elnyelni vagy létrehozni.
Tenzor	A tenzor reprezentálja a műveletek között haladó adatokat. Korábban látta, hogyan kell inicializálni a tenzort. Az állandó és a változó közötti különbség az, hogy a változó kezdeti értékei az idő múlásával megváltoznak.
Ülés	Egy munkamenet végrehajtja a műveletet a grafikonról. Ahhoz, hogy a grafikont egy tenzor értékeivel táplálja, meg kell nyitnia egy munkamenetet. A munkameneten belül futtatnia kell egy operátort a kimenet létrehozásához.

A grafikonok és a munkamenetek függetlenek. Futtathat egy munkamenetet, és megszerezheti azokat az értékeket, amelyeket később felhasználhat a további számításokhoz.

Az alábbi példában:

• Hozzon létre két tenzort
• Hozzon létre egy műveletet
• Nyisson meg egy munkamenetet
• Nyomtassa ki az eredményt

1. lépés: Hozzon létre két x és y tenzort

## Create, run and evaluate a sessionx = tf.constant([2])y = tf.constant([4]) 

2. lépés: Az operátort az x és az y szorzásával hozza létre

## Create operatormultiply = tf.multiply(x, y) 

3. lépés: Megnyit egy munkamenetet. Az összes számítás a munkameneten belül történik. Ha végzett, be kell zárnia a munkamenetet.

## Create a session to run the codesess = tf.Session()result_1 = sess.run(multiply)print(result_1)sess.close() 

Kimenet

[8] 

Kódmagyarázat

• tf.Session (): Nyisson meg egy munkamenetet. Az összes művelet a munkameneteken belül fog folyni
• futtatás (szorzás): hajtsa végre a 2. lépésben létrehozott műveletet.
• nyomtatás (eredmény_1): Végül kinyomtathatja az eredményt
• bezár (): Bezárja a munkamenetet

Az eredmény 8-at mutat, ami az x és y szorzata.

A munkamenet létrehozásának másik módja egy blokk belsejében található. Előnye, hogy automatikusan lezárja a munkamenetet.

with tf.Session() as sess:result_2 = multiply.eval()print(result_2) 

Kimenet

[8] 

A munkamenet kontextusában az eval () metódust használhatja a művelet végrehajtására. A futással () egyenértékű. Ez a kódot olvashatóbbá teszi.

Létrehozhat egy munkamenetet, és megtekintheti az eddig létrehozott tenzorok értékeit.

## Check the tensors created beforesess = tf.Session()print(sess.run(r1))print(sess.run(r2_matrix))print(sess.run(r3_matrix)) 

Kimenet

1[[1 2][3 4]][[[1 2][3 4][5 6]]] 

A változók alapértelmezés szerint üresek, még egy tenzor létrehozása után is. Inicializálnia kell a változót, ha használni szeretné a változót. A tf.global_variables_initializer () objektumot meg kell hívni a változó értékeinek inicializálásához. Ez az objektum kifejezetten inicializálja az összes változót. Ez hasznos, mielőtt betanít egy modellt.

Ellenőrizheti a korábban létrehozott változók értékeit. Vegye figyelembe, hogy a tenzor kiértékeléséhez a futá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)) 

Kimenet

[[-0.05356491 0.75867283]][[0 0]][[10 20][30 40]] 

Használhatja a korábban létrehozott helyőrzőt, és betöltheti tényleges értékkel. Át kell adnia az adatokat a feed_dict metódusba.

Például a data_placeholder_a helyőrzőből kettő hatalmát veszi át.

import numpy as nppower_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álja a numpy könyvtárat az adatok létrehozásához
• tf.pow (data_placeholder_a, 2): Hozza létre az opokat
• np.random.rand (1, 10): Hozzon létre egy véletlenszerű tömböt
• feed_dict = {data_placeholder_a: data}: Adja meg a helyőrzőt adatokkal

Kimenet

[[0.05478134 0.27213147 0.8803037 0.0398424 0.21172127 0.01444725 0.02584014 0.3763949 0.66022706 0.7565559 ]] 

Grafikon

A TensorFlow egy zseniális megközelítéstől függ a művelet végrehajtásához. Az összes számítást egy adatfolyam-séma szemlélteti. Az adatfolyam-grafikont azért fejlesztették ki, hogy megnézze az egyes műveletek közötti adatfüggéseket. A matematikai képlet vagy algoritmus számos egymást követő műveletből áll. A grafikon kényelmes módszer a számítások összehangolásának vizualizálására.

A grafikon egy csomópontot és egy élt mutat . A csomópont egy művelet, azaz a számítási egység ábrázolása. Az él a tenzor, új tenzort képes előállítani, vagy felhasználhatja a bemenő adatokat. Ez az egyes műveletek közötti függőségektől függ.

A grafikon felépítése összeköti a műveleteket (azaz a csomópontokat) és azt, hogy ezek hogyan működnek. Vegye figyelembe, hogy a grafikon nem jeleníti meg a műveletek kimenetét, csak az egyes műveletek közötti kapcsolat vizualizálását segíti.

Lássunk egy példát.

Képzelje el, hogy ki szeretné értékelni a következő függvényt:

A TensorFlow létrehoz egy grafikont a függvény végrehajtásához. A grafikon így néz ki:

TensorFlow Graph példa

Könnyen láthatja az utat, amelyen a tenzorok végig fognak érni a végső célig.

Például láthatja, hogy az add művelet nem hajtható végre a és előtt. A grafikon elmagyarázza, hogy:

1. kiszámítja és:
2. add hozzá az 1) pontot
3. hozzá 2)
4. adjunk hozzá 3) -t

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 5 állandó értékkel
• z: Inicializálja az z nevű változót 6 állandó értékkel
• c: Inicializálja a c nevű állandó tenzort 5 állandó értékkel
• négyzet: Inicializáljon egy állandó tenzort, amelyet négyzetnek nevezünk, állandó értéke 2
• f: Konstruálja az operátort

Ebben a példában a változók értékeinek rögzített maradását választjuk. Létrehoztunk egy állandó nevű c tenzort is, amely az f függvény állandó paramétere. Ez fix értéket vesz fel. A grafikonon ezt a paramétert láthatja az állandónak nevezett tenzorban.

A tf.pow () operátorban állandó feszültséget is létrehoztunk. Nem szükséges. Úgy tettünk, hogy a grafikonon láthassa a tenzor nevét. Ez a négyzetnek nevezett kör.

A grafikon alapján megértheti, hogy mi fog történni a tenzorokkal, és hogyan adhatja vissza a 66-os kimenetet.

Az alábbi kód a munkamenet függvényét értékeli.

init = tf.global_variables_initializer() # prepare to initialize all variableswith tf.Session() as sess:init.run() # Initialize x and yfunction_result = f.eval()print(function_result) 

Kimenet

[66] 

Összegzés

A TensorFlow működik:

• Grafikon : A műveleteket és a tenzorokat tartalmazó számítási környezet
• Tenzorok : A grafikonon áramló adatokat (vagy értékeket) képviseli. Ez a gráf éle
• Munkamenetek : A műveletek végrehajtásának engedélyezése

Hozzon létre egy állandó feszültséget

állandó	tárgy
D0	tf.constant (1, tf.int16)
D1	tf. konstans ([1,3,5], tf.int16)
D2	tf. konstans ([[1, 2], [3, 4]], tf.int16)
D3	tf. konstans ([[[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. sokszor (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 munkamenetet	tf.Session.run ()
Értékeljen egy tenzort	változó_neve.eval ()
Zárjon be egy munkamenetet	sess.close ()
Munkamenet blokkonként	tf.Session () mint sess: