Co je tenzor v TensorFlow? Tvar, typ a Operatorů

Co je to tenzor?

Název TensorFlow je odvozen přímo od svého hlavního objektu: tenzoru. V TensorFlow každý výpočet zahrnuje tenzory. Tenzor je vektor nebo matice o n dimenzích, která reprezentuje všechny typy dat. Všechny hodnoty v tenzoru mají stejný datový typ se známým (nebo částečně známým) tvarem a tvar dat je dimenzionalita 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 sada výpočtů, které probíhají postupně. Každá operace se nazývá operační uzel a uzly jsou vzájemně propojeny.

Graf znázorňuje operace a propojení mezi uzly. Nezobrazuje však hodnoty. Hrana mezi uzly je tenzor, tj. způsob, jak naplnit operaci daty.

Ve strojovém učení jsou modely napájeny seznamem objektů nazývaných vektory rysů. Vektor rysů může být libovolného datového typu a obvykle je primárním vstupem, který naplňuje tenzor. Tyto hodnoty proudí do operačního uzlu přes tenzor a výsledek této operace vytváří nový tenzor, který se následně používá v nové operaci. Všechny tyto operace lze zobrazit v grafu.

Zastoupení tenzora

V TensorFlow je tenzor kolekce vektorů rysů (tj. pole) o n dimenzích. Například pokud máme matici 2×3 s hodnotami od 1 do 6, zapíšeme ji jako matici uvedenou níže:

TensorFlow představuje tuto matici jako:

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

Pokud vytvoříme trojrozměrnou matici s hodnotami od 1 do 8, stejná data se vykreslí jako kvádr se dvěma naskládanými plochami:

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ří dimenzí. Vizualizace úrovní vyšších dimenzí je jednoduše obtížnější.

Typy tenzorů

V TensorFlow všechny výpočty procházejí 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 provádíte s TensorFlow, zahrnuje manipulaci s tenzorem. Existují čtyři hlavní typy tenzorů, které můžete vytvořit:

• tf.Variable
• tf.constant
• tf.placeholder
• tf.SparseTensor

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

Před spuštěním kódu je třeba mít na paměti jednu věc: tento tutoriál se řídí původním rozhraním TensorFlow 1.x API, kde se graf nejprve vytvoří a poté se spouští v rámci relace. TensorFlow 2 běží ve výchozím nastavení energicky, takže několik níže uvedených symbolů bylo přesunuto nebo odstraněno. Každý z nich je stále dosažitelný prostřednictvím tf.compat.v1 jmenný prostor a tabulka mapuje každý z nich na jeho moderní protějšek.

Než začnete s tutoriálem, ujistěte se, že máte aktivované prostředí conda, ve kterém je nainstalován TensorFlow. Toto prostředí se nazývá hello-tf.

Pro macOS uživatelé:

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

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

Pro vytvoření tenzoru můžete použít tf.constant() jak je znázorněno v 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 o dimenzi 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)

Tři části tohoto výstupu se mapují na tři vlastnosti tenzoru, jak jasně ukazuje níže uvedená anotovaná verze.

Tenzoru můžete také dát vlastní název pomocí name argument.

# 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 svým názvem. Každý objekt tenzoru je definován atributy, jako je jedinečný popisek (název), rozměr (tvar) a datový typ 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 o dimenzi 1 lze vytvořit následovně:

## Rank 1
r1_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 se 2 tenzorovými dimenzemi, musíte uzavřít závorky za každým řádkem. Podívejte se na příklad tvaru tenzoru 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 a 4.

Matice se 3 rozměry se sestrojí přidáním další úrovně 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)

Výsledek odpovídá trojrozměrnému krabicovému diagramu zobrazenému dříve v tomto tutoriálu.

Tvar tenzoru

Když vytisknete tenzor, TensorFlow odvodí jeho tvar. Tvar však můžete přečíst přímo pomocí TensorFlow. shape vlastnictví.

Níže sestrojíte matici naplněnou čísly 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)

Tato vlastnost funguje i pro matici. Zde vytvoříte matici 10×10 naplněnou číslem 1.

# Create a vector of 1
print(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 3×2, takže následující kód vytvoří tenzor se 3 řádky vyplněnými jednotkami:

# 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 do závorky vložíte hodnotu 1, sestrojíte vektor jedniček 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 vyplněnou výhradně jednotkami.

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 obsahovat najednou pouze jeden typ dat a tento typ lze číst pomocí dtype vlastnictví.

print(m_shape.dtype)

Výstup

<dtype: &#x27;int32'>

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

Příklad

Níže je tenzor s plovoucí čárkou převeden na celé číslo pomocí cast metoda.

# 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: &#x27;float32'>
<dtype: &#x27;int32'>

TensorFlow automaticky vybere typ dat, pokud není argument zadán během vytváření tenzoru. TensorFlow odhadne nejpravděpodobnější typ dat: pokud například předáte text, odvodí řetězec.

Vytvoření OperaTor

Některé užitečné funkce TensorFlow Operatorů

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 jednoduchou operací a použít metodu TensorFlow k výpočtu druhé odmocniny z čísla. Tato operace je přímočará, protože k vytvoření tenzoru je potřeba pouze jeden argument.

Druhá odmocnina z čísla se sestrojí pomocí tf.sqrt(x), kde x je číslo s plovoucí desetinnou čárkou.

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 druhou odmocninu ze 2. V tomto příkladu se vypíše definice tenzoru, nikoli skutečné vyhodnocení operace. V níže uvedené části Relace se dozvíte, jak TensorFlow provádí operace.

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.subtract(a, b)
• tf.multiply(a, b)
• tf.divide(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)

Code Vysvětlení

Vytvořte dva tenzory:

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

Sečtete oba tenzory.

Všimněte si, že oba tenzory musí mít stejný tvar. Můžete také provést násobení obou tenzorů.

# Multiply
tensor_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, což samo o sobě má omezené využití. Data vždy přicházejí s různými hodnotami a k ​​jejich zachycení můžete použít třídu Variable. Proměnná představuje uzel, jehož hodnoty se v čase mění.

Pro vytvoření proměnné můžete použít tf.get_variable() metoda.

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í TensorFlow vrací 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)

V tomto příkladu vytvoříte proměnnou s jedním řádkem a dvěma sloupci, takže jako dimenzi proměnné předáte [1, 2].

Počáteční hodnoty tenzoru mohou být také nulové. Například při trénování modelu potřebujete počáteční hodnoty před výpočtem váhy rysů. Níže tyto počáteční hodnoty nastavíte 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 také předat proměnné. Konstantní tenzor vytvoříte metodou tf.constant() a použijte tento tenzor k inicializaci proměnné.

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

# Create a 2x2 matrix
tensor_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 slouží k napájení tenzoru. Zástupný symbol inicializuje data, která budou proudit uvnitř tenzorů. Pro poskytnutí zástupného symbolu se používá feed_dict argument a zástupný symbol je podáván pouze v rámci relace.

V dalším příkladu uvidíte, jak vytvořit zástupný symbol pomocí metody tf.placeholderV sekci Relace se naučíte, jak do zástupného symbolu vložit skutečnou hodnotu 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í

Grafy a relace jsou nezávislé. Můžete spustit relaci a uchovat hodnoty pro pozdější 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íhají v rámci relace a po jejím dokončení ji musíte zavřít.

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

Výstup

[8]

Code vysvětlení

• tf.Session(): Otevření relace. Všechny operace probíhají v rámci relace.
• run(multiply): provést operaci vytvořenou v kroku 2
• print(result_1)Nakonec můžete výsledek vytisknout
• close()Ukončit 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, že se relace automaticky ukončí.

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

Výstup

[8]

V kontextu relace můžete použít eval() metoda pro provedení operace. Je to ekvivalentní run() a kód se pak lépe čte.

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é, a to i po vytvoření tenzoru. Před použitím je nutné proměnnou inicializovat. Objekt tf.global_variables_initializer() se volá k inicializaci hodnot všech proměnných najednou, což 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 je třeba použít příkaz 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 zadat do něj skutečnou hodnotu. Data musíte předat do feed_dict argument.

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.

Code Vysvětlení

• import numpy as np: Importujte soubor nemotorný knihovna pro vytvář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}Do zástupného symbolu vložte data

Výstup

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

Graf

TensorFlow vykresluje každou operaci pomocí schématu datového toku. Graf datového toku byl navržen tak, aby zobrazoval datové závislosti mezi jednotlivými operacemi. Matematický vzorec nebo algoritmus se skládá z řady po sobě jdoucích operací a graf je pohodlný způsob, jak vizualizovat, jak jsou tyto výpočty koordinovány.

Graf zobrazuje uzly a hrany. Uzel je reprezentací operace, tj. výpočetní jednotkou. Hrana je tenzor: může vytvořit nový tenzor nebo spotřebovat vstupní data v závislosti na závislostech mezi jednotlivými operacemi.

Struktura grafu propojuje operace (tj. uzly) dohromady a ukazuje, jak je každá z nich napájena. Graf nezobrazuje výstup operací; pouze pomáhá vizualizovat propojení mezi nimi.

Podívejme se na příklad. Představte si, že chcete vyhodnotit následující funkci:

TensorFlow vytvoří graf pro spuštění funkce. Graf vypadá takto:

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

Například, add uzel nemůže běžet před oběma Mul a Pow přinesli své výsledky. Graf ukazuje, že TensorFlow bude:

1. vypočítejte x·z v Mul uzel a x² v Pow uzel
2. sečtěte tyto dva výsledky dohromady v add uzel
3. přičtěte z k tomuto součtu v add_1 uzel
4. přidejte konstantu 5 do add_2 uzel

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

Code Vysvětlení

• 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 jsou hodnoty proměnných ponechány pevné. Konstantní tenzor c je konstantní parametr ve funkci f a nabývá pevné hodnoty 5; v grafu můžete tento parametr v tenzoru nazvaný konstanta vidět.

Pro mocninu v operátoru byl také vytvořen konstantní tenzor tf.pow()Není to nutné, ale znamená to, že exponent se v grafu objeví jako kruh zvaný čtverec.

Z grafu můžete sledovat, co se děje s tenzory a proč funkce vrací 66: 5 × 6 plus 5² plus 6 plus 5 se rovná 66.

Následující kód vyhodnocuje funkci uvnitř relace.

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]

Stručný přehled základů TensorFlow

Čtyři níže uvedené tabulky shromažďují všechny příkazy použité v tomto tutoriálu, abyste si je mohli vyhledat, aniž byste se museli vracet zpět příklady.

Vytvořte konstantní tenzor

Vytvořte operátora

Vytvořte proměnný tenzor

Otevřete relaci

Nejčastější dotazy