Základy TensorFlow: Tenzor, Tvar, Typ, Session & Operátoři

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á představuje 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ěrnost 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 množina výpočtů, která probíhá postupně. Každá operace se nazývá operační uzel a jsou navzájem propojeny.

Graf nastiňuje operace a spojení mezi uzly. Nezobrazuje však hodnoty. Okraj uzlů je tenzor, tj. Způsob vyplnění operace daty.

V Machine Learning se modely krmí seznamem objektů, které se nazývají vektory funkcí. Vektor prvku může být jakéhokoli datového typu. Vektor prvku bude obvykle primárním vstupem k naplnění tenzoru. Tyto hodnoty budou proudit 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.

V tomto tutoriálu se naučíte základy TensorFlow jako -

• Co je to tenzor?
• Zastoupení tenzoru
• Typy tenzoru
• Vytvořte tenzor n-dimenze
• Tvar tenzoru
• Typ údajů
• Vytváření operátorů
• Některé užitečné operátory TensorFlow
• Proměnné
• Zástupný symbol
• Zasedání
• Graf

Zastoupení tenzoru

V TensorFlow je tenzor sbírka vektorů prvků (tj. Pole) n-rozměrů. Například pokud máme matici 2x3 s hodnotami od 1 do 6, napíšeme:

Zastoupení tenzoru

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ů. Je jen složitější představit si vyšší dimenzi.

Typy tenzoru

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 provedete s TensorFlow, zahrnuje manipulaci s tenzorem. Můžete vytvořit čtyři hlavní typy tenzorů:

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

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

Než projdeme tutoriálem, nezapomeňte aktivovat prostředí conda pomocí TensorFlow. Toto prostředí jsme pojmenovali hello-tf.

Pro uživatele systému MacOS:

source activate hello-tf 

Pro uživatele Windows:

activate hello-tf 

Poté, co jste to udělali, jste připraveni importovat tensorflow

# Import tfimport tensorflow as tf 

Vytvořte tenzor n-dimenze

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

Chcete-li vytvořit tenzor, můžete použít tf.constant (), jak je znázorněno v následující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 namer1 = tf.constant(1, tf.int16)print(r1)

Výstup

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

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

Výstup

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

Každý tenzor je zobrazen podle názvu tenzoru. Každý tenzorový objekt je definován pomocí tenzorových atributů, jako je jedinečný štítek (název), dimenze (tvar) a datové typy TensorFlow (dtype).

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

# Decimalr1_decimal = tf.constant(1.12345, tf.float32)print(r1_decimal)# Stringr1_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 řadu 2 tenzorových rozměrů, musíte zavřít závorky po každém řádku. Podívejte se níže na příklad tvaru Keras Tensor

## Rank 2r2_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 je vytvořena přidáním další úrovně v závorkách.

## Rank 3r3_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 dva.

Tvar tenzoru

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

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

# Shape of tensorm_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 k vytvoření vektoru nebo matice vyplněné 0 nebo 1. Například pokud chcete vytvořit 1-D tenzor se specifickým tvarem 10, vyplněný 0, můžete spustit následující kód:

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

Výstup

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

Vlastnost funguje i pro matici. Zde vytvoříte matici 10x10 naplněnou 1

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

Výstup

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

Tvar dané matice můžete použít k vytvoření vektoru jedniček. Matice m_shape má rozměry 3x2. 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_shapeprint(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_shapeprint(tf.ones(m_shape.shape[1])) 

Výstup

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

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

print(tf.ones(m_shape.shape)) 

Výstup

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

Typ údajů

Druhou vlastností tenzoru je typ dat. Tenzor může mít najednou pouze jeden typ dat. Tenzor může mít pouze jeden typ dat. Typ můžete vrátit pomocí vlastnosti dtype.

print(m_shape.dtype) 

Výstup

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

Výstup

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

Vytváření operátorů

Některé užitečné operátory TensorFlow

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

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

Čtverec čísla je konstruován s tf.sqrt (x) s x jako plovoucí číslo.

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 tenzorový objekt a ne výsledek druhé mocniny 2. V příkladu vytisknete definici tenzoru a ne 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

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

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

Sčítáte oba tenzory.

Upozornění : oba tenzory musí mít stejný tvar. Můžete provést násobení přes dva tenzory.

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

Výstup

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

Proměnné

Zatím jste vytvořili pouze konstantní tenzory. Není to moc užitečné. Data vždy přicházejí s různými hodnotami, abyste je mohli zachytit, můžete použít třídu Proměnná. 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. OptionalIf 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í TensorFlow vrací náhodnou hodnotu. Pojmenujete proměnnou var

# Create a Variable## Create 2 Randomized valuesvar = 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]

Hodnoty iniciál tohoto tenzoru jsou nulové. Například když trénujete model, musíte mít počáteční hodnoty pro výpočet váhy prvků. Níže nastavíte 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) 

V proměnné můžete předat hodnoty konstantního tenzoru. 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 2x2.

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

Výstup

(2, 2) 

Zástupný symbol

Zástupný symbol má účel napájet tenzor. Zástupný symbol se používá k inicializaci dat, která budou proudit uvnitř tenzorů. Chcete-li zadat zástupný symbol, musíte použít metodu feed_dict. Zástupný symbol bude krmen pouze v rámci relace.

V dalším příkladu uvidíte, jak vytvořit zástupný symbol pomocí metody tf.placeholder. V další relaci se naučíte krmit zástupný symbol skutečnou tenzorovou hodnotou.

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. Optionaldata_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 pracuje kolem 3 hlavních komponent:

• Graf
• Tenzor
• Zasedání

Součásti	Descritption
Graf	Graf je v TensorFlow zásadní. Všechny matematické operace (operace) se provádějí uvnitř grafu. Graf si můžete představit jako projekt, kde se provádějí všechny operace. Uzly představují tyto operace, mohou absorbovat nebo vytvářet nové tenzory.
Tenzor	Tenzor představuje data, která postupují mezi operacemi. Dříve jste viděli, jak inicializovat tenzor. Rozdíl mezi konstantou a proměnnou spočívá v tom, že počáteční hodnoty proměnné se budou časem měnit.
Zasedání	Relace provede operaci z grafu. Chcete-li graf napájet hodnotami tenzoru, musíte otevřít relaci. Uvnitř relace musíte spustit operátor a vytvořit výstup.

Grafy a relace jsou nezávislé. Můžete spustit relaci a získat hodnoty, které se později použijí 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 sessionx = tf.constant([2])y = tf.constant([4]) 

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

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

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

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

Výstup

[8] 

Vysvětlení kódu

• tf.Session (): Otevřete relaci. Všechny operace budou probíhat v rámci relací
• spustit (znásobit): provést operaci vytvořenou v kroku 2.
• print (result_1): Nakonec můžete výsledek vytisknout
• close (): Ukončení relace

Výsledek ukazuje 8, což je násobení xay.

Další způsob, jak vytvořit relaci, je uvnitř bloku. Výhodou je, že relaci automaticky uzavře.

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 beforesess = 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. Chcete-li proměnnou použít, musíte ji inicializovat. K inicializaci hodnot proměnné je třeba volat 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 nakrmit ho skutečnou hodnotou. Musíte předat data do metody feed_dict.

Například vezmete moc 2 zástupného symbolu data_placeholder_a.

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. 

Vysvětlení kódu

• import numpy jako np: Importuje numpy knihovnu pro vytvoření dat
• tf.pow (data_placeholder_a, 2): Vytvořte operace
• np.random.rand (1, 10): Vytvořte náhodné pole dat
• feed_dict = {data_placeholder_a: data}: Vlož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, aby sledoval závislosti na datech mezi jednotlivými operacemi. Matematický vzorec nebo algoritmus jsou tvořeny řadou po sobě následujících operací. Graf je pohodlný způsob, jak vizualizovat, jak jsou výpočty koordinovány.

Graf ukazuje uzel a hranu . Uzel je reprezentací operace, tj. Výpočetní jednotkou. Hrana je tenzor, může produkovat nový tenzor nebo spotřebovávat vstupní data. Závisí to na závislostech mezi jednotlivými operacemi.

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

Podívejme se na příklad.

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

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

Příklad grafu TensorFlow

Můžete snadno vidět cestu, kterou se tenzory vydají k dosažení konečného cíle.

Například můžete vidět, že přidání operace nelze provést dříve a. Graf vysvětluje, že:

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

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: Inicializuje proměnnou nazvanou x s ​​konstantní hodnotou 5
• z: Inicializujte proměnnou nazvanou z s konstantní hodnotou 6
• c: Inicializujte konstantní tenzor zvaný c s konstantní hodnotou 5
• square: Inicializuje konstantní tenzor zvaný square s konstantní hodnotou 2
• f: Sestavte operátora

V tomto příkladu jsme se rozhodli zachovat hodnoty proměnných pevné. Také jsme vytvořili konstantní tenzor s názvem c, což je parametr konstanty 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 proto, abyste v grafu viděli název tenzoru. 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 vyhodnotí funkci v relaci.

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) 

Výstup

[66] 

souhrn

TensorFlow funguje kolem:

• Graf : Výpočtové prostředí obsahující operace a tenzory
• Tenzory : Představuje data (nebo hodnotu), která budou plynout v grafu. Je to hrana v grafu
• Relace : 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. konstantní ([[[[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, initializer = [[1, 2], [3, 4]])

Otevřete relaci

Zasedání	objekt
Vytvořte relaci	tf.Session ()
Spusťte relaci	tf.Session.run ()
Vyhodnoťte tenzor	variable_name.eval ()
Ukončete relaci	sess.close ()
Zasedání po bloku	s tf.Session () jako sess: