Základy TensorFlow: Tensor, tvar, typ, relace a Operatorů

Co je to tenzor?

Název Tensorflow je přímo odvozen od jeho základního rámce: Tensor. V Tensorflow všechny výpočty zahrnují tenzory. Tenzor je vektor nebo matice n-dimenzí, která reprezentuje všechny typy dat. Všechny hodnoty v tenzoru obsahují identický datový typ se známým (nebo částečně známým) tvarem. Tvar dat je rozměr matice nebo pole.

Tenzor může pocházet ze vstupních dat nebo z výsledku výpočtu. V TensorFlow jsou všechny operace prováděny uvnitř grafu. Graf je soubor výpočtů, které probíhají postupně. Každá operace se nazývá operační uzel a jsou vzájemně propojeny.

Graf ukazuje operace a spojení mezi uzly. Nezobrazuje však hodnoty. Hrana uzlů je tenzor, tj. způsob, jak naplnit operaci daty.

Ve strojovém učení jsou modely zásobovány seznamem objektů nazývaných vektory prvků. Charakterový vektor může být libovolného datového typu. Charakteristický vektor bude obvykle primárním vstupem pro naplnění tenzoru. Tyto hodnoty potečou do operačního uzlu přes tenzor a výsledek této operace/výpočtu vytvoří nový tenzor, který bude zase použit v nové operaci. Všechny tyto operace lze zobrazit v grafu.

Zastoupení tenzora

V TensorFlow je tensor sbírka příznakových vektorů (tj. pole) n-dimenzí. Pokud máme například matici 2×3 s hodnotami od 1 do 6, zapíšeme:

TensorFlow představuje tuto matici jako:

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

Pokud vytvoříme trojrozměrnou matici s hodnotami od 1 do 8, máme:

TensorFlow představuje tuto matici jako:

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

Poznámka: Tenzor může být reprezentován skalárem nebo může mít tvar více než tří rozměrů. Jen je složitější vizualizovat vyšší úroveň dimenze.

Typy tenzorů

V TensorFlow procházejí všechny výpočty jedním nebo více tenzory. Tf.tensor je objekt se třemi vlastnostmi:

• Jedinečný štítek (jméno)
• rozměr (tvar)
• datový typ (dtype)

Každá operace, kterou s TensorFlow provedete, zahrnuje manipulaci s tenzorem. Existují čtyři hlavní typy tenzorů, které můžete vytvořit:

• tf.Proměnná
• tf.konstantní
• tf.placeholder
• tf.SparseTensor

V tomto tutoriálu se naučíte, jak vytvořit tf.constant a tf.Variable.

Než projdeme tutoriál, ujistěte se, že jste aktivovali prostředí conda pomocí TensorFlow. Toto prostředí jsme pojmenovali hello-tf.

Pro uživatele MacOS:

source activate hello-tf

Pro Windows uživatel:

activate hello-tf

Poté, co to uděláte, jste připraveni importovat tensorflow

# Import tf
import tensorflow as tf

Vytvořte tenzor n-rozměru

Začnete vytvořením tenzoru s jednou dimenzí, konkrétně skalárem.

Chcete-li vytvořit tenzor, můžete použít tf.constant(), jak je znázorněno na níže uvedeném příkladu tvaru tenzoru TensorFlow:

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`

Chcete-li vytvořit tenzor dimenze 0, spusťte následující kód

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

Výstup

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

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

Výstup

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

Každý tenzor je zobrazen pod názvem tenzoru. Každý objekt tenzoru je definován pomocí atributů tenzoru, jako je jedinečný štítek (název), rozměr (tvar) a datové typy TensorFlow (dtype).

Tenzor můžete definovat s desítkovými hodnotami nebo s řetězcem změnou typu dat.

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

Výstup

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

Tenzor dimenze 1 lze vytvořit následovně:

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

Výstup

Tensor("Const_3:0", shape=(3,), dtype=int16)
Tensor("Const_4:0", shape=(3,), dtype=bool)

Můžete si všimnout, že tvar TensorFlow se skládá pouze z 1 sloupce.

Chcete-li vytvořit pole 2 rozměrů tenzoru, musíte uzavřít závorky po každém řádku. Podívejte se na příklad tvaru Keras Tensor níže

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

Výstup

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

Matice má 2 řádky a 2 sloupce vyplněné hodnotami 1, 2, 3, 4.

Matice se 3 rozměry se vytvoří přidáním další úrovně pomocí závorek.

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

Výstup

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

Matice vypadá jako na obrázku dvě.

Tvar tenzoru

Když tisknete tenzor, TensorFlow odhadne tvar. Tvar tenzoru však můžete získat pomocí vlastnosti tvaru TensorFlow.

Níže vytvoříte matici vyplněnou číslem od 10 do 15 a zkontrolujete tvar m_shape

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

Výstup

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

Matice má 3 řádky a 2 sloupce.

TensorFlow má užitečné příkazy pro vytvoření vektoru nebo matice vyplněné 0 nebo 1. Pokud například chcete vytvořit 1-D tenzor se specifickým tvarem 10, vyplněný 0, můžete spustit níže uvedený kód:

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

Výstup

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

Vlastnost funguje i pro matrix. Zde vytvoříte matici 10×10 vyplněnou 1

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

Výstup

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

Pomocí tvaru dané matice můžete vytvořit vektor jedniček. Matice m_shape má rozměry 3×2. Můžete vytvořit tenzor se 3 řádky vyplněnými jedním s následujícím kódem:

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

Výstup

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

Pokud předáte hodnotu 1 do závorky, můžete sestrojit vektor jedniček, který se rovná počtu sloupců v matici m_shape.

# Create a vector of ones with the same number of column as m_shape
print(tf.ones(m_shape.shape[1]))

Výstup

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

Nakonec můžete vytvořit matici 3×2 pouze s jednou

print(tf.ones(m_shape.shape))

Výstup

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

Typ dat

Druhou vlastností tenzoru je typ dat. Tenzor může mít současně pouze jeden typ dat. Tenzor může mít pouze jeden typ dat. Typ můžete vrátit s vlastností dtype.

print(m_shape.dtype)

Výstup

<dtype: 'int32'>

V některých případech chcete změnit typ dat. V TensorFlow je to možné pomocí metody tf.cast.

Příklad

Níže je plovoucí tenzor převeden na celé číslo pomocí metody cast.

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

Výstup

<dtype: 'float32'>
<dtype: 'int32'>

TensorFlow vybere typ dat automaticky, když argument není zadán během vytváření tenzoru. TensorFlow bude hádat, jaké jsou nejpravděpodobnější typy dat. Pokud například předáte text, uhodne, že se jedná o řetězec, a převede jej na řetězec.

Vytváření operátora

Několik užitečných operátorů TensorFlow

Víte, jak vytvořit tenzor pomocí TensorFlow. Je čas naučit se provádět matematické operace.

TensorFlow obsahuje všechny základní operace. Můžete začít s jednoduchým. K výpočtu druhé mocniny čísla použijete metodu TensorFlow. Tato operace je přímočará, protože ke konstrukci tenzoru je zapotřebí pouze jeden argument.

Druhá mocnina čísla je vytvořena pomocí tf.sqrt(x) s x jako plovoucím číslem.

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

Výstup

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

Poznámka: Výstup vrátil objekt tenzoru, nikoli výsledek druhé mocniny 2. V příkladu vytisknete definici tenzoru, nikoli skutečné vyhodnocení operace. V další části se dozvíte, jak TensorFlow funguje při provádění operací.

Následuje seznam běžně používaných operací. Myšlenka je stejná. Každá operace vyžaduje jeden nebo více argumentů.

• 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říklad

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

Výstup

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

Vysvětlení kódu

Vytvořte dva tenzory:

• jeden tenzor s 1 a 2
• jeden tenzor s 3 a 4

Sečtete oba tenzory.

Oznámení: že oba tenzory musí mít stejný tvar. Přes dva tenzory můžete provést násobení.

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

Výstup

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

Proměnné

Doposud jste vytvářeli pouze konstantní tenzory. Nemá velké využití. Data vždy přicházejí s jinými hodnotami, k jejich zachycení můžete použít třídu Variable. Bude představovat uzel, kde se hodnoty vždy mění.

Chcete-li vytvořit proměnnou, můžete použít metodu tf.get_variable().

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.

Například níže uvedený kód vytvoří dvourozměrnou proměnnou se dvěma náhodnými hodnotami. Ve výchozím nastavení vrací TensorFlow náhodnou hodnotu. Proměnnou pojmenujete var

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

Výstup

(1, 2)

Ve druhém příkladu vytvoříte proměnnou s jedním řádkem a dvěma sloupci. K vytvoření dimenze proměnné musíte použít [1,2]

Počáteční hodnoty tohoto tenzoru jsou nulové. Když například trénujete model, potřebujete mít počáteční hodnoty, abyste mohli vypočítat váhu prvků. Níže nastavte tyto počáteční hodnoty na nulu.

var_init_1 = tf.get_variable("var_init_1", [1, 2], dtype=tf.int32,  initializer=tf.zeros_initializer)
print(var_init_1.shape)

Výstup

(1, 2)

Hodnoty konstantního tenzoru můžete předávat v proměnné. Konstantní tenzor vytvoříte metodou tf.constant(). Tento tenzor použijete k inicializaci proměnné.

První hodnoty proměnné jsou 10, 20, 30 a 40. Nový tenzor bude mít tvar 2×2.

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

Výstup

(2, 2)

Zástupný

Zástupný symbol má za úkol napájet tenzor. Zástupný symbol se používá k inicializaci dat pro tok uvnitř tenzorů. Chcete-li zadat zástupný symbol, musíte použít metodu feed_dict. Zástupný symbol bude poskytnut pouze v rámci relace.

V dalším příkladu uvidíte, jak vytvořit zástupný symbol metodou tf.placeholder. V další relaci se naučíte přidávat zástupný symbol skutečnou hodnotou tenzoru.

Syntaxe je:

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)

Výstup

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

Zasedání

TensorFlow funguje kolem 3 hlavních komponent:

• Graf
• tensor
• Zasedání

Komponenty	Popis
Graf	Graf je v TensorFlow zásadní. Všechny matematické operace (ops) se provádějí uvnitř grafu. Graf si můžete představit jako projekt, kde se provádějí všechny operace. Uzly reprezentují tyto operace, mohou absorbovat nebo vytvářet nové tenzory.
tensor	Tenzor představuje data, která postupují mezi operacemi. Dříve jste viděli, jak inicializovat tenzor. Rozdíl mezi konstantou a proměnnou je, že počáteční hodnoty proměnné se budou v průběhu času měnit.
Zasedání	Relace provede operaci z grafu. Chcete-li graf naplnit hodnotami tenzoru, musíte otevřít relaci. Uvnitř relace musíte spustit operátor pro vytvoření výstupu.

Grafy a relace jsou nezávislé. Můžete spustit relaci a získat hodnoty pro pozdější použití pro další výpočty.

V níže uvedeném příkladu budete:

• Vytvořte dva tenzory
• Vytvořte operaci
• Otevřete relaci
• Vytiskněte výsledek

Krok 1) Vytvoříte dva tenzory x a y

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

Krok 2) Operátor vytvoříte vynásobením x a y

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

Krok 3) Otevřete relaci. Všechny výpočty proběhnou během relace. Až budete hotovi, musíte relaci ukončit.

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

Výstup

[8]

Vysvětlení kódu

• tf.Session(): Otevření relace. Všechny operace budou probíhat v rámci relací
• run(multiply): proveďte operaci vytvořenou v kroku 2.
• print(result_1): Nakonec můžete vytisknout výsledek
• close(): Uzavře relaci

Výsledek ukazuje 8, což je násobení x a y.

Dalším způsobem, jak vytvořit relaci, je uvnitř bloku. Výhodou je automatické ukončení relace.

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

Výstup

[8]

V kontextu relace můžete k provedení operace použít metodu eval(). Je ekvivalentní run(). Díky tomu je kód čitelnější.

Můžete vytvořit relaci a zobrazit hodnoty uvnitř tenzorů, které jste dosud vytvořili.

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

Výstup

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

Proměnné jsou ve výchozím nastavení prázdné, i když vytvoříte tenzor. Pokud chcete proměnnou použít, musíte proměnnou inicializovat. K inicializaci hodnot proměnné je třeba zavolat objekt tf.global_variables_initializer(). Tento objekt explicitně inicializuje všechny proměnné. To je užitečné před trénováním modelu.

Můžete zkontrolovat hodnoty proměnných, které jste vytvořili dříve. Všimněte si, že k vyhodnocení tenzoru musíte použít run

sess.run(tf.global_variables_initializer())
print(sess.run(var))
print(sess.run(var_init_1))
print(sess.run(var_init_2))

Výstup

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

Můžete použít zástupný symbol, který jste vytvořili dříve, a poskytnout mu skutečnou hodnotu. Data musíte předat do metody feed_dict.

Například budete mít mocninu 2 zástupného symbolu data_placeholder_a.

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.

Vysvětlení kódu

• import numpy as np: Import nudná knihovna k vytvoření dat
• tf.pow(data_placeholder_a, 2): Vytvořte ops
• np.random.rand(1, 10): Vytvořte náhodné pole dat
• feed_dict={data_placeholder_a: data}: Naplňte zástupný symbol daty

Výstup

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

Graf

TensorFlow závisí na geniálním přístupu k vykreslení operace. Všechny výpočty jsou reprezentovány schématem toku dat. Graf toku dat byl vyvinut pro sledování závislostí dat mezi jednotlivými operacemi. Matematický vzorec nebo algoritmus se skládá z řady po sobě jdoucích operací. Graf je pohodlný způsob, jak vizualizovat, jak jsou výpočty koordinovány.

Graf ukazuje a uzel a hrana. Uzel je reprezentací operace, tj. jednotky výpočtu. Hrana je tenzor, může vytvořit nový tenzor nebo spotřebovat vstupní data. Záleží na závislostech mezi jednotlivými operacemi.

Struktura grafu spojuje dohromady operace (tj. uzly) a způsob, jakým jsou operace podávány. Všimněte si, že graf nezobrazuje výstup operací, pouze pomáhá vizualizovat souvislosti mezi jednotlivými operacemi.

Podívejme se na příklad.

Představte si, že chcete vyhodnotit následující funkci:

TensorFlow vytvoří graf pro provedení funkce. Graf vypadá takto:

Můžete snadno vidět cestu, kterou tenzory projdou, aby dosáhly konečného cíle.

Můžete například vidět, že operaci přidání nelze provést před a . Graf vysvětluje, že to bude:

1. vypočítat a:
2. přidat 1) dohromady
3. přidat do 2)
4. přidat 3) k

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

Vysvětlení kódu

• x: Inicializujte proměnnou s názvem x s konstantní hodnotou 5
• z: Inicializuje proměnnou nazvanou z s konstantní hodnotou 6
• c: Inicializujte konstantní tenzor nazvaný c s konstantní hodnotou 5
• čtverec: Inicializuje konstantní tenzor nazývaný čtverec s konstantní hodnotou 2
• f: Sestrojte operátor

V tomto příkladu se rozhodneme ponechat hodnoty proměnných pevné. Vytvořili jsme také konstantní tenzor nazvaný c, což je konstantní parametr ve funkci f. Trvá pevnou hodnotu 5. V grafu můžete tento parametr vidět v tenzoru zvaném konstanta.

Také jsme zkonstruovali konstantní tenzor pro výkon v operátoru tf.pow(). Není to nutné. Udělali jsme to tak, že název tenzoru vidíte v grafu. Je to kruh zvaný čtverec.

Z grafu můžete pochopit, co se stane s tenzory a jak může vrátit výstup 66.

Níže uvedený kód vyhodnocuje funkci v relaci.

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)

Výstup

[66]

Shrnutí

TensorFlow funguje kolem:

• Graf: Výpočtové prostředí obsahující operace a tenzory
• Tenzory: Představuje data (nebo hodnotu), která potečou v grafu. Je to hrana v grafu
• Sessions: Povolit provádění operací

Vytvořte konstantní tenzor

konstantní	objekt
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)

Vytvořte operátora

Vytvořte operátora	Objekt
a + b	tf.add(a, b)
a*b	tf.multiply(a, b)

Vytvořte proměnný tenzor

Vytvořte proměnnou	objekt
náhodná hodnota	tf.get_variable("var", [1, 2])
inicializovaná první hodnota	tf.get_variable(“var_init_2”, dtype=tf.int32, inicializátor=[ [1, 2], [3, 4] ])

Otevřete relaci

Zasedání	objekt
Vytvořte relaci	tf.Session()
Spusťte relaci	tf.Session.run()
Vyhodnoťte tenzor	název_proměnné.eval()
Zavřete relaci	sess.close()
Relace po bloku	s tf.Session() jako sess: