Základy TensorFlow: Tenzor, Tvar, Typ, Relácie & Operátorov

Čo je to tenzor?

Názov Tensorflow je priamo odvodený z jeho základného rámca: Tensor. V Tensorflowe všetky výpočty zahŕňajú tenzory. Tenzor je vektor alebo matica n-dimenzií, ktorá predstavuje všetky typy údajov. Všetky hodnoty v tenzore obsahujú identický dátový typ so známym (alebo čiastočne známym) tvarom. Tvar údajov je rozmernosť matice alebo poľa.

Tenzor môže pochádzať zo vstupných údajov alebo z výsledku výpočtu. V TensorFlow sú všetky operácie vykonávané vo vnútri grafu. Graf je množina výpočtov, ktorá sa uskutočňuje postupne. Každá operácia sa nazýva operačný uzol a sú navzájom spojené.

Graf načrtáva operácie a spojenia medzi uzlami. Nezobrazuje však hodnoty. Okraj uzlov je tenzor, tj spôsob vyplnenia operácie dátami.

V strojovom učení sa modely kŕmia zoznamom objektov, ktoré sa nazývajú vektory funkcií. Vektor znakov môže byť ľubovoľného typu údajov. Vektor funkcií bude zvyčajne primárnym vstupom na vyplnenie tenzora. Tieto hodnoty budú prúdiť do operačného uzla cez tenzor a výsledkom tejto operácie / výpočtu bude nový tenzor, ktorý bude následne použitý v novej operácii. Všetky tieto operácie je možné zobraziť v grafe.

V tomto tutoriáli sa dozviete základné informácie o TensorFlow, ako napríklad

• Čo je to tenzor?
• Zastúpenie tenzora
• Typy tenzora
• Vytvorte tenzor n-dimenzie
• Tvar tenzora
• Typ údajov
• Vytvára sa operátor
• Niektorí užitoční operátori TensorFlow
• Premenné
• Zástupný symbol
• Session
• Graf

Zastúpenie tenzora

V TensorFlow je tenzor súborom vektorov funkcií (tj. Poľa) n-rozmerov. Napríklad, ak máme maticu 2x3 s hodnotami od 1 do 6, napíšeme:

Zastúpenie tenzora

TensorFlow predstavuje túto maticu ako:

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

Ak vytvoríme trojrozmernú maticu s hodnotami od 1 do 8, máme:

TensorFlow predstavuje túto maticu ako:

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

Poznámka: Tenzor môže byť reprezentovaný skalárom alebo môže mať tvar viac ako troch rozmerov. Je len komplikovanejšie vizualizovať vyššiu úroveň dimenzie.

Typy tenzora

V TensorFlow prechádzajú všetky výpočty jedným alebo viacerými tenzormi. Tf.tensor je objekt s tromi vlastnosťami:

• Jedinečný štítok (meno)
• Rozmer (tvar)
• Typ údajov (dtype)

Každá operácia, ktorú urobíte s TensorFlow, zahŕňa manipuláciu s tenzorom. Môžete vytvoriť štyri hlavné typy tenzorov:

• tf. Premenná
• tf. konštantný
• tf.placeholder
• tf.SparseTensor

V tomto tutoriáli sa dozviete, ako vytvoriť tf.constant a tf.Variable.

Predtým, ako prejdeme tutoriálom, nezabudnite aktivovať prostredie conda pomocou TensorFlow. Toto prostredie sme pomenovali hello-tf.

Pre používateľov systému MacOS:

source activate hello-tf 

Pre používateľov systému Windows:

activate hello-tf 

Potom ste pripravení na import tenzorflowu

# Import tfimport tensorflow as tf 

Vytvorte tenzor n-dimenzie

Začínate tvorbou tenzora s jednou dimenziou, konkrétne so skalárom.

Ak chcete vytvoriť tenzor, môžete použiť tf.constant (), ako je uvedené v nasledujúcom príklade tvaru tenzora 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` 

Ak chcete vytvoriť tenzor dimenzie 0, spustite nasledujúci kód

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

Výkon

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

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

Výkon

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

Každý tenzor sa zobrazuje podľa názvu tenzora. Každý tenzorový objekt je definovaný s tenzorovými atribútmi, ako je jedinečný štítok (názov), dimenzia (tvar) a dátové typy TensorFlow (dtype).

Tenzor môžete definovať s desatinnými hodnotami alebo pomocou reťazca zmenou typu údajov.

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

Výkon

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

Tenzor dimenzie 1 je možné vytvoriť nasledovne:

## 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ýkon

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

Môžete si všimnúť, že tvar TensorFlow sa skladá iba z 1 stĺpca.

Ak chcete vytvoriť pole s 2 rozmermi tenzora, musíte za každým riadkom zavrieť zátvorky. Skontrolujte príklad tvaru Keras Tensor nižšie

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

Výkon

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

Matica má 2 riadky a 2 stĺpce vyplnené hodnotami 1, 2, 3, 4.

Matica s 3 rozmermi je zostrojená pridaním ďalšej úrovne do zátvoriek.

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

Výkon

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

Matica vyzerá ako na obrázku dva.

Tvar tenzora

Keď tlačíte tensor, TensorFlow odhadne tvar. Tvar tenzora však môžete získať pomocou vlastnosti tvaru TensorFlow.

Ďalej zostrojíte maticu naplnenú číslom od 10 do 15 a skontrolujete tvar m_shape

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

Výkon

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

Matica má 3 riadky a 2 stĺpce.

TensorFlow má užitočné príkazy na vytvorenie vektora alebo matice naplnenej 0 alebo 1. Napríklad, ak chcete vytvoriť 1-D tenzor so špecifickým tvarom 10, naplnený 0, môžete spustiť kód uvedený nižšie:

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

Výkon

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

Vlastnosť funguje aj pre maticu. Tu vytvoríte maticu 10x10 naplnenú 1

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

Výkon

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

Pomocou tvaru danej matice môžete vytvoriť vektor jednotiek. Matica m_shape má rozmery 3x2. Môžete vytvoriť tenzor s 3 riadkami vyplnenými jedným s nasledujúcim kódom:

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

Výkon

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

Ak zadáte hodnotu 1 do zátvorky, môžete v matici m_shape zostrojiť vektor tých, ktorý sa rovná počtu stĺpcov.

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

Výkon

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

Nakoniec môžete vytvoriť maticu 3x2 iba s jednou

print(tf.ones(m_shape.shape)) 

Výkon

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

Typ údajov

Druhou vlastnosťou tenzora je typ údajov. Tenzor môže mať súčasne iba jeden typ údajov. Tenzor môže mať iba jeden typ údajov. Typ môžete vrátiť s vlastnosťou dtype.

print(m_shape.dtype) 

Výkon

V niektorých prípadoch budete chcieť zmeniť typ údajov. V TensorFlow je to možné pomocou metódy tf.cast.

Príklad

Nižšie je plavákový tenzor prevedený na celé číslo pomocou metódy 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ýkon

TensorFlow vyberie typ údajov automaticky, keď počas vytvárania tenzora nie je zadaný argument. TensorFlow uhádne, aké sú najpravdepodobnejšie typy údajov. Ak napríklad zadáte text, bude uhádnuť, že ide o reťazec, a prevedie ho na reťazec.

Vytvára sa operátor

Niektorí užitoční operátori TensorFlow

S TensorFlow viete, ako vytvoriť tenzor. Je čas naučiť sa, ako vykonávať matematické operácie.

TensorFlow obsahuje všetky základné operácie. Môžete začať jednoduchým. Na výpočet štvorca čísla použijete metódu TensorFlow. Táto operácia je jednoduchá, pretože na zostavenie tenzora je potrebný iba jeden argument.

Druhá mocnina čísla je zostrojená s tf.sqrt (x), pričom x je plávajúce číslo.

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

Výkon

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

Poznámka: Výstup vrátil objekt tenzora a nie výsledok štvorca 2. V príklade vytlačíte definíciu tenzora a nie skutočné vyhodnotenie operácie. V nasledujúcej časti sa dozviete, ako TensorFlow pracuje na vykonávaní operácií.

Nasleduje zoznam bežne používaných operácií. Myšlienka je rovnaká. Každá operácia vyžaduje jeden alebo viac argumentov.

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

Prí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ýkon

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

Vysvetlenie kódu

Vytvorte dva tenzory:

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

Sčítate oba tenzory.

Poznámka : oba tenzory musia mať rovnaký tvar. Môžete vykonať multiplikáciu cez dva tenzory.

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

Výkon

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

Premenné

Doteraz ste vytvorili iba konštantné tenzory. Nemá veľké využitie. Dáta prichádzajú vždy s rôznymi hodnotami, aby ste ich zachytili, môžete použiť triedu Premenná. Bude predstavovať uzol, kde sa hodnoty vždy menia.

Na vytvorenie premennej môžete použiť metódu 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. 

Napríklad nasledujúci kód vytvára dvojrozmernú premennú s dvoma náhodnými hodnotami. TensorFlow predvolene vracia náhodnú hodnotu. Premennú pomenujete var

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

Výkon

(1, 2) 

V druhom príklade vytvoríte premennú s jedným riadkom a dvoma stĺpcami. Na vytvorenie dimenzie premennej musíte použiť [1,2]

Počiatočné hodnoty tohto tenzora sú nulové. Napríklad keď trénujete model, musíte mať počiatočné hodnoty, aby ste mohli vypočítať váhu prvkov. Ďalej nastavíte tieto počiatoč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ýkon

(1, 2) 

V premennej môžete odovzdať hodnoty konštantného tenzora. Konštantný tenzor vytvoríte metódou tf.constant (). Tento tenzor použijete na inicializáciu premennej.

Prvé hodnoty premennej sú 10, 20, 30 a 40. Nový tenzor bude mať 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ýkon

(2, 2) 

Zástupný symbol

Účelom zástupného symbolu je napájanie tenzora. Zástupný symbol sa používa na inicializáciu údajov, ktoré majú prúdiť vnútri tenzorov. Ak chcete zadať zástupný symbol, musíte použiť metódu feed_dict. Zástupný symbol bude kŕmený iba v rámci relácie.

V nasledujúcom príklade uvidíte, ako vytvoriť zástupný symbol pomocou metódy tf.placeholder. V nasledujúcej relácii sa naučíte kŕmiť zástupný symbol skutočnou tenzorovou hodnotou.

Syntax 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ýkon

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

Session

TensorFlow pracuje okolo 3 hlavných komponentov:

• Graf
• Tenzor
• Session

Komponenty	Descritption
Graf	Graf je v TensorFlow zásadný. Všetky matematické operácie (ops) sa uskutočňujú v grafe. Graf si môžete predstaviť ako projekt, kde sa vykonávajú všetky operácie. Uzly reprezentujú tieto operácie, môžu absorbovať alebo vytvárať nové tenzory.
Tenzor	Tenzor predstavuje dáta, ktoré postupujú medzi operáciami. Už ste videli, ako inicializovať tenzor. Rozdiel medzi konštantou a premennou predstavuje počiatočné hodnoty premennej, ktoré sa budú časom meniť.
Session	Relácia vykoná operáciu z grafu. Ak chcete graf napájať hodnotami tenzora, musíte otvoriť reláciu. V relácii musíte spustiť operátor, ktorý vytvorí výstup.

Grafy a relácie sú nezávislé. Môžete spustiť reláciu a získať hodnoty, ktoré sa majú neskôr použiť na ďalšie výpočty.

V príklade nižšie budete robiť:

• Vytvorte dva tenzory
• Vytvorte operáciu
• Otvorte reláciu
• Výsledok vytlačte

Krok 1) Vytvoríte dva tenzory x a y

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

Krok 2) Operátora vytvoríte vynásobením znakov x a y

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

Krok 3) Otvoríte reláciu. Všetky výpočty sa uskutočnia v rámci relácie. Keď skončíte, musíte reláciu ukončiť.

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

Výkon

[8] 

Vysvetlenie kódu

• tf.Session (): Otvorte reláciu. Všetky operácie budú prebiehať v rámci relácií
• spustiť (vynásobiť): vykonať operáciu vytvorenú v kroku 2.
• print (result_1): Nakoniec môžete výsledok vytlačiť
• close (): Ukončí reláciu

Výsledok ukazuje 8, čo je násobenie x a y.

Ďalším spôsobom, ako vytvoriť reláciu, je blok. Výhodou je, že reláciu automaticky uzavrie.

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

Výkon

[8] 

V kontexte relácie môžete na vykonanie operácie použiť metódu eval (). Je ekvivalentom run (). Zvyšuje čitateľnosť kódu.

Môžete vytvoriť reláciu a pozrieť sa na hodnoty vo vnútri tenzorov, ktoré ste doteraz vytvorili.

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

Výkon

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

Premenné sú predvolene prázdne, a to aj po vytvorení tenzora. Ak chcete premennú použiť, musíte ju inicializovať. Na inicializáciu hodnôt premennej je potrebné zavolať objekt tf.global_variables_initializer (). Tento objekt výslovne inicializuje všetky premenné. To je užitočné skôr, ako model trénujete.

Môžete skontrolovať hodnoty premenných, ktoré ste vytvorili predtým. Na vyhodnotenie tenzora musíte použiť run

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

Výkon

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

Môžete použiť zástupný symbol, ktorý ste vytvorili predtým, a kŕmiť ho skutočnou hodnotou. Údaje musíte odovzdať metóde feed_dict.

Naprí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. 

Vysvetlenie kódu

• import numpy ako np: Importuje numpy knižnicu na vytvorenie údajov
• tf.pow (data_placeholder_a, 2): Vytvorte ops
• np.random.rand (1, 10): Vytvorte náhodné pole údajov
• feed_dict = {data_placeholder_a: data}: Vložte zástupný symbol do dát

Výkon

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

Graf

TensorFlow závisí od geniálneho prístupu pri vykresľovaní operácie. Všetky výpočty sú reprezentované schémou toku údajov. Graf toku údajov bol vyvinutý s cieľom dohliadnuť na závislosti údajov medzi jednotlivými operáciami. Matematický vzorec alebo algoritmus sú tvorené z niekoľkých po sebe nasledujúcich operácií. Graf je pohodlný spôsob, ako vizualizovať koordináciu výpočtov.

Graf zobrazuje uzol a hranu . Uzol je reprezentáciou operácie, tj výpočtovou jednotkou. Okraj je tenzor, ktorý dokáže vytvoriť nový tenzor alebo spotrebovať vstupné údaje. Závisí to od závislostí medzi jednotlivými operáciami.

Štruktúra grafu spája operácie (tj. Uzly) a spôsob napájania týchto operácií. Upozorňujeme, že graf nezobrazuje výstup operácií, pomáha iba vizualizovať spojenie medzi jednotlivými operáciami.

Pozrime sa na príklad.

Predstavte si, že chcete vyhodnotiť nasledujúcu funkciu:

TensorFlow vytvorí graf na vykonanie funkcie. Graf vyzerá takto:

Príklad grafu TensorFlow

Ľahko vidíte cestu, ktorou sa tenzory dostanú do konečného cieľa.

Napríklad môžete vidieť, že operáciu nemožno pridať pred a. Graf vysvetľuje, že:

1. vypočítať a:
2. sčítať 1) spolu
3. pridať do 2)
4. pridať 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 

Vysvetlenie kódu

• x: Inicializuje premennú nazvanú x s konštantnou hodnotou 5
• z: Inicializujte premennú nazvanú z s konštantnou hodnotou 6
• c: Inicializujte konštantný tenzor nazývaný c s konštantnou hodnotou 5
• štvorec: Inicializuje sa konštantný tenzor nazývaný štvorec s konštantnou hodnotou 2
• f: Zostrojte operátora

V tomto príklade sme sa rozhodli ponechať hodnoty premenných pevné. Tiež sme vytvorili konštantný tenzor s názvom c, ktorý je konštantným parametrom vo funkcii f. Má pevnú hodnotu 5. V grafe môžete tento parameter vidieť v tenzore nazývanom konštanta.

Konštruovali sme tiež konštantný tenzor pre výkon v operátore tf.pow (). Nie je to nutné. Urobili sme to tak, aby ste v grafe videli názov tenzora. Je to kruh zvaný štvorec.

Z grafu môžete pochopiť, čo sa stane s tenzormi a ako môže vrátiť výstup 66.

Nasledujúci kód hodnotí funkciu v relácii.

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ýkon

[66] 

Zhrnutie

TensorFlow funguje okolo:

• Graf : Výpočtové prostredie obsahujúce operácie a tenzory
• Tenzory : Predstavuje údaje (alebo hodnotu), ktoré budú plynúť v grafe. Je to hrana v grafe
• Relácie : Umožnite vykonávanie operácií

Vytvorte konštantný tenzor

konštantný	objekt
D0	tf.constant (1, tf.int16)
D1	tf.konštantná ([1,3,5], tf.int16)
D2	tf.stále ([[1, 2], [3, 4]], tf.int16)
D3	tf.stále ([[[[1, 2], [3, 4], [5, 6]]], tf.int16)

Vytvorte operátora

Vytvorte operátora	Objekt
a + b	tf.add (a, b)
a * b	tf.multiply (a, b)

Vytvorte variabilný tenzor

Vytvorte premennú	objekt
náhodná hodnota	tf.get_variable ("var", [1, 2])
inicializovaná prvá hodnota	tf.get_variable ("var_init_2", dtype = tf.int32, initializer = [[1, 2], [3, 4]])

Otvorte reláciu

Session	objekt
Vytvorte reláciu	tf.Session ()
Spustite reláciu	tf.Session.run ()
Vyhodnoťte tenzor	variable_name.eval ()
Ukončiť reláciu	sess.close ()
Relácia po bloku	s tf.Session () ako sess: