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:

Tenzor ábrázolása
Tenzor ábrázolása

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:

Tenzor ábrázolása

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)

Hozzon létre egy n-dimenziós tenzort

# 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:

Grafikon

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

TensorFlow Graph példa

TensorFlow Graph példa

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:

  1. kiszámítja és:
  2. add 1) együtt
  3. add hozzá a 2-hez)
  4. 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: