Osnove TensorFlowa: tenzor, oblik, vrsta, sesije & Operaulagatelji
Evelyn Clarke
Što je tenzor?
Ime Tensorflowa izravno je izvedeno iz njegovog temeljnog okvira: Tensor. U Tensorflowu svi proračuni uključuju tenzore. Tenzor je vektor ili matrica n-dimenzija koja predstavlja sve vrste podataka. Sve vrijednosti u tenzoru sadrže identičan tip podataka s poznatim (ili djelomično poznatim) oblikom. Oblik podataka je dimenzionalnost matrice ili niza.
Tenzor može nastati iz ulaznih podataka ili rezultata izračuna. U TensorFlowu se sve operacije provode unutar grafa. Graf je skup izračuna koji se odvija sukcesivno. Svaka operacija se naziva operativni čvor i međusobno su povezani.
Grafikon ocrtava operacije i veze između čvorova. Međutim, ne prikazuje vrijednosti. Rub čvorova je tenzor, tj. način da se operacija popuni podacima.
U strojnom učenju, modeli se unose popisom objekata koji se nazivaju vektori značajki. Vektor obilježja može biti bilo koje vrste podataka. Vektor obilježja obično će biti primarni ulaz za popunjavanje tenzora. Ove vrijednosti će teći u operativni čvor kroz tenzor, a rezultat ove operacije/izračunavanja će stvoriti novi tenzor koji će se zauzvrat koristiti u novoj operaciji. Sve ove operacije mogu se vidjeti na grafikonu.
Reprezentacija tenzora
U TensorFlowu, tenzor je zbirka vektora značajki (tj. niza) n-dimenzija. Na primjer, ako imamo matricu 2×3 s vrijednostima od 1 do 6, pišemo:
TensorFlow predstavlja ovu matricu kao:
[[1, 2, 3], [4, 5, 6]]
Ako kreiramo trodimenzionalnu matricu s vrijednostima od 1 do 8, imamo:
TensorFlow predstavlja ovu matricu kao:
[ [[1, 2],
[[3, 4],
[[5, 6],
[[7,8] ]
Bilješka: Tenzor se može prikazati skalarom ili može imati oblik više od tri dimenzije. Samo je kompliciranije vizualizirati višu razinu dimenzija.
Vrste tenzora
U TensorFlowu sva izračunavanja prolaze kroz jedan ili više tenzora. tf.tensor je objekt s tri svojstva:
- Jedinstvena oznaka (ime)
- Dimenzija (oblik)
- Vrsta podataka (dtype)
Svaka operacija koju ćete učiniti s TensorFlowom uključuje manipulaciju tenzorom. Postoje četiri glavne vrste tenzora koje možete kreirati:
- tf.Promjenljiva
- tf.konstantan
- tf.rezervirano mjesto
- tf.SparseTensor
U ovom ćete vodiču naučiti kako stvoriti tf.constant i tf.Variable.
Prije nego što prođemo kroz tutorial, provjerite jeste li aktivirali conda okruženje s TensorFlowom. Ovo okruženje nazvali smo hello-tf.
Za korisnika MacOS-a:
source activate hello-tf
Za Windows korisnik:
activate hello-tf
Nakon što to učinite, spremni ste za uvoz tensorflowa
# Import tf import tensorflow as tf
Napravite tenzor n-dimenzije
Počinjete stvaranjem tenzora s jednom dimenzijom, naime skalarom.
Za izradu tenzora možete koristiti tf.constant() kao što je prikazano u donjem primjeru oblika 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`
Za stvaranje tenzora dimenzije 0, pokrenite sljedeći kod
## rank 0 # Default name r1 = tf.constant(1, tf.int16) print(r1)
Izlaz
Tensor("Const:0", shape=(), dtype=int16)
# Named my_scalar r2 = tf.constant(1, tf.int16, name = "my_scalar") print(r2)
Izlaz
Tensor("my_scalar:0", shape=(), dtype=int16)
Svaki tenzor je prikazan imenom tenzora. Svaki objekt tenzora definiran je atributima tenzora kao što su jedinstvena oznaka (ime), dimenzija (oblik) i tipovi podataka TensorFlow (dtype).
Tenzor možete definirati s decimalnim vrijednostima ili s nizom promjenom vrste podataka.
# Decimal
r1_decimal = tf.constant(1.12345, tf.float32)
print(r1_decimal)
# String
r1_string = tf.constant("Guru99", tf.string)
print(r1_string)
Izlaz
Tensor("Const_1:0", shape=(), dtype=float32)
Tensor("Const_2:0", shape=(), dtype=string)
Tenzor dimenzije 1 može se kreirati na sljedeći način:
## 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)
Izlaz
Tensor("Const_3:0", shape=(3,), dtype=int16)
Tensor("Const_4:0", shape=(3,), dtype=bool)
Možete primijetiti da se oblik TensorFlow sastoji samo od 1 stupca.
Da biste stvorili niz od 2 dimenzije tenzora, morate zatvoriti zagrade nakon svakog retka. Pogledajte primjer oblika Kerasovog tenzora u nastavku
## Rank 2
r2_matrix = tf.constant([ [1, 2],
[3, 4] ],tf.int16)
print(r2_matrix)
Izlaz
Tensor("Const_5:0", shape=(2, 2), dtype=int16)
Matrica ima 2 retka i 2 stupca ispunjena vrijednostima 1, 2, 3, 4.
Matrica s 3 dimenzije se konstruira dodavanjem još jedne razine sa zagradama.
## Rank 3
r3_matrix = tf.constant([ [[1, 2],
[3, 4],
[5, 6]] ], tf.int16)
print(r3_matrix)
Izlaz
Tensor("Const_6:0", shape=(1, 3, 2), dtype=int16)
Matrica izgleda kao na slici 2.
Oblik tenzora
Kada ispisujete tenzor, TensorFlow pogađa oblik. Međutim, možete dobiti oblik tenzora sa svojstvom oblika TensorFlow.
U nastavku konstruirate matricu ispunjenu brojevima od 10 do 15 i provjerite oblik m_shape
# Shape of tensor
m_shape = tf.constant([ [10, 11],
[12, 13],
[14, 15] ]
)
m_shape.shape
Izlaz
TensorShape([Dimension(3), Dimension(2)])
Matrica ima 3 retka i 2 stupca.
TensorFlow ima korisne naredbe za stvaranje vektora ili matrice ispunjene s 0 ili 1. Na primjer, ako želite stvoriti 1-D tenzor s određenim oblikom 10, ispunjenim s 0, možete pokrenuti kod u nastavku:
# Create a vector of 0 print(tf.zeros(10))
Izlaz
Tensor("zeros:0", shape=(10,), dtype=float32)
Svojstvo vrijedi i za matricu. Ovdje stvarate matricu 10×10 ispunjenu s 1
# Create a vector of 1 print(tf.ones([10, 10]))
Izlaz
Tensor("ones:0", shape=(10, 10), dtype=float32)
Možete upotrijebiti oblik zadane matrice da napravite vektor jedinica. Matrica m_shape je dimenzija 3×2. Možete stvoriti tenzor s 3 retka ispunjena jednim pomoću sljedećeg koda:
# Create a vector of ones with the same number of rows as m_shape print(tf.ones(m_shape.shape[0]))
Izlaz
Tensor("ones_1:0", shape=(3,), dtype=float32)
Ako prenesete vrijednost 1 u zagradu, možete konstruirati vektor od jedinica jednak broju stupaca u matrici m_shape.
# Create a vector of ones with the same number of column as m_shape print(tf.ones(m_shape.shape[1]))
Izlaz
Tensor("ones_2:0", shape=(2,), dtype=float32)
Konačno, možete stvoriti matricu 3×2 samo s jednim
print(tf.ones(m_shape.shape))
Izlaz
Tensor("ones_3:0", shape=(3, 2), dtype=float32)
Vrsta podataka
Drugo svojstvo tenzora je vrsta podataka. Tenzor može imati samo jednu vrstu podataka u isto vrijeme. Tenzor može imati samo jednu vrstu podataka. Možete vratiti tip sa svojstvom dtype.
print(m_shape.dtype)
Izlaz
<dtype: 'int32'>
U nekim slučajevima želite promijeniti vrstu podataka. U TensorFlowu je to moguće pomoću metode tf.cast.
Primjer
U nastavku se tenzor float pretvara u cijeli broj korištenjem metode 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)
Izlaz
<dtype: 'float32'> <dtype: 'int32'>
TensorFlow automatski odabire vrstu podataka kada argument nije naveden tijekom stvaranja tenzora. TensorFlow će pogoditi koja je najvjerojatnija vrsta podataka. Na primjer, ako proslijedite tekst, on će pogoditi da je niz i pretvoriti ga u niz.
Izrada operatora
Neki korisni TensorFlow operatori
Znate kako stvoriti tenzor s TensorFlowom. Vrijeme je da naučite izvoditi matematičke operacije.
TensorFlow sadrži sve osnovne operacije. Možete početi s jednostavnim. Koristit ćete metodu TensorFlow za izračunavanje kvadrata broja. Ova operacija je jednostavna jer je za konstrukciju tenzora potreban samo jedan argument.
Kvadrat broja konstruiran je s tf.sqrt(x) s x kao pokretnim brojem.
x = tf.constant([2.0], dtype = tf.float32) print(tf.sqrt(x))
Izlaz
Tensor("Sqrt:0", shape=(1,), dtype=float32)
Bilješka: Izlaz je vratio objekt tenzora, a ne rezultat kvadrata 2. U primjeru ispisujete definiciju tenzora, a ne stvarnu procjenu operacije. U sljedećem odjeljku naučit ćete kako TensorFlow radi na izvršavanju operacija.
Slijedi popis često korištenih operacija. Ideja je ista. Svaka operacija zahtijeva jedan ili više argumenata.
- 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)
Primjer
# 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)
Izlaz
Tensor("Add:0", shape=(1, 2), dtype=int32)
Objašnjenje koda
Napravite dva tenzora:
- jedan tenzor s 1 i 2
- jedan tenzor s 3 i 4
Zbrajate oba tenzora.
obavijest: da oba tenzora moraju imati isti oblik. Možete izvršiti množenje nad dva tenzora.
# Multiply tensor_multiply = tf.multiply(tensor_a, tensor_b) print(tensor_multiply)
Izlaz
Tensor("Mul:0", shape=(1, 2), dtype=int32)
Varijable
Do sada ste kreirali samo konstantne tenzore. Nije od velike koristi. Podaci uvijek stižu s različitim vrijednostima, da biste to uhvatili, možete koristiti klasu Variable. Predstavljat će čvor u kojem se vrijednosti uvijek mijenjaju.
Za izradu varijable možete koristiti 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.
Na primjer, kod u nastavku stvara dvodimenzionalnu varijablu s dvije nasumične vrijednosti. TensorFlow prema zadanim postavkama vraća slučajnu vrijednost. Vi varijablu imenujete var
# Create a Variable
## Create 2 Randomized values
var = tf.get_variable("var", [1, 2])
print(var.shape)
Izlaz
(1, 2)
U drugom primjeru stvarate varijablu s jednim retkom i dva stupca. Morate upotrijebiti [1,2] za stvaranje dimenzije varijable
Početne vrijednosti ovog tenzora su nula. Na primjer, kada trenirate model, morate imati početne vrijednosti za izračunavanje težine značajki. U nastavku ove početne vrijednosti postavljate 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)
Izlaz
(1, 2)
Možete proslijediti vrijednosti konstantnog tenzora u varijabli. Konstantni tenzor stvarate metodom tf.constant(). Ovaj tenzor koristite za inicijalizaciju varijable.
Prve vrijednosti varijable su 10, 20, 30 i 40. Novi tenzor će imati oblik 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)
Izlaz
(2, 2)
Činovnik
Svrha čuvara mjesta je da dopuni tenzor. Rezervirano mjesto se koristi za pokretanje protoka podataka unutar tenzora. Da biste unijeli rezervirano mjesto, morate koristiti metodu feed_dict. Rezervirano mjesto bit će uneseno samo unutar sesije.
U sljedećem primjeru vidjet ćete kako stvoriti rezervirano mjesto metodom tf.placeholder. U sljedećoj ćete sesiji naučiti staviti rezervirano mjesto stvarnom vrijednošću tenzora.
Sintaksa 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)
Izlaz
Tensor("data_placeholder_a:0", dtype=float32)
Sjednica
TensorFlow radi oko 3 glavne komponente:
- Grafikon
- tenzor
- Sjednica
| Komponente | Opis |
|---|---|
| Grafikon | Graf je fundamentalan u TensorFlowu. Sve matematičke operacije (ops) izvode se unutar grafa. Možete zamisliti graf kao projekt u kojem se obavljaju sve operacije. Čvorovi predstavljaju te operacije, mogu apsorbirati ili stvoriti nove tenzore. |
| tenzor | Tenzor predstavlja podatke koji napreduju između operacija. Prethodno ste vidjeli kako inicijalizirati tenzor. Razlika između konstante i varijable je u tome što će se početne vrijednosti varijable mijenjati tijekom vremena. |
| Sjednica | Sesija će izvršiti operaciju iz grafikona. Da biste graf napunili vrijednostima tenzora, morate otvoriti sesiju. Unutar sesije morate pokrenuti operator za stvaranje izlaza. |
Grafikoni i sesije su neovisni. Možete pokrenuti sesiju i dobiti vrijednosti koje ćete kasnije koristiti za daljnje izračune.
U donjem primjeru ćete:
- Napravite dva tenzora
- Stvorite operaciju
- Otvorite sesiju
- Ispišite rezultat
Korak 1) Kreirate dva tenzora x i y
## Create, run and evaluate a session x = tf.constant([2]) y = tf.constant([4])
Korak 2) Operator stvarate množenjem x i y
## Create operator multiply = tf.multiply(x, y)
Korak 3) Otvarate sesiju. Sva izračunavanja dogodit će se unutar sesije. Kada ste gotovi, trebate zatvoriti sesiju.
## Create a session to run the code sess = tf.Session()result_1 = sess.run(multiply) print(result_1) sess.close()
Izlaz
[8]
Objašnjenje koda
- tf.Session(): Otvaranje sesije. Sve će operacije teći unutar sesija
- run(multiply): izvršite operaciju stvorenu u koraku 2.
- print(result_1): Konačno, možete ispisati rezultat
- close(): Zatvori sesiju
Rezultat pokazuje 8, što je množenje x i y.
Drugi način stvaranja sesije je unutar bloka. Prednost je što automatski zatvara sesiju.
with tf.Session() as sess: result_2 = multiply.eval() print(result_2)
Izlaz
[8]
U kontekstu sesije, možete koristiti metodu eval() za izvršenje operacije. To je ekvivalentno run(). Čini kôd čitljivijim.
Možete stvoriti sesiju i vidjeti vrijednosti unutar tenzora koje ste do sada stvorili.
## Check the tensors created before sess = tf.Session() print(sess.run(r1)) print(sess.run(r2_matrix)) print(sess.run(r3_matrix))
Izlaz
1 [[1 2] [3 4]] [[[1 2] [3 4] [5 6]]]
Varijable su prema zadanim postavkama prazne, čak i nakon što stvorite tenzor. Morate inicijalizirati varijablu ako želite koristiti varijablu. Objekt tf.global_variables_initializer() treba pozvati za inicijalizaciju vrijednosti varijable. Ovaj će objekt eksplicitno inicijalizirati sve varijable. Ovo je korisno prije nego što obučite model.
Možete provjeriti vrijednosti varijabli koje ste prije stvorili. Imajte na umu da morate koristiti run za procjenu tenzora
sess.run(tf.global_variables_initializer()) print(sess.run(var)) print(sess.run(var_init_1)) print(sess.run(var_init_2))
Izlaz
[[-0.05356491 0.75867283]] [[0 0]] [[10 20] [30 40]]
Možete upotrijebiti rezervirano mjesto koje ste prije stvorili i dodati mu stvarnu vrijednost. Morate proslijediti podatke u metodu feed_dict.
Na primjer, uzet ćete snagu 2 rezerviranog mjesta 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.
Objašnjenje koda
- import numpy kao np: Import knjižnica numpy za stvaranje podataka
- tf.pow(data_placeholder_a, 2): Kreirajte ops
- np.random.rand(1, 10): Stvorite nasumični niz podataka
- feed_dict={data_placeholder_a: data}: Ubaci podatke u rezervirano mjesto
Izlaz
[[0.05478134 0.27213147 0.8803037 0.0398424 0.21172127 0.01444725 0.02584014 0.3763949 0.66022706 0.7565559 ]]
Grafikon
TensorFlow ovisi o genijalnom pristupu renderiranja operacije. Sva su izračunavanja predstavljena shemom tijeka podataka. Grafikon protoka podataka razvijen je kako bi se uočile ovisnosti podataka između pojedinačnih operacija. Matematička formula ili algoritam sastoji se od niza uzastopnih operacija. Grafikon je prikladan način za vizualizaciju načina na koji su proračuni koordinirani.
Grafikon prikazuje a čvor i rub. Čvor je prikaz operacije, tj. jedinica izračuna. Rub je tenzor, može proizvesti novi tenzor ili potrošiti ulazne podatke. Ovisi o ovisnosti između pojedinih operacija.
Struktura grafa povezuje operacije (tj. čvorove) i način na koji se te operacije dovode. Imajte na umu da grafikon ne prikazuje izlaz operacija, on samo pomaže vizualizirati vezu između pojedinačnih operacija.
Pogledajmo primjer.
Zamislite da želite procijeniti sljedeću funkciju:
TensorFlow će stvoriti grafikon za izvršenje funkcije. Grafikon izgleda ovako:
Lako možete vidjeti put kojim će tenzori doći do konačnog odredišta.
Na primjer, možete vidjeti da se operacija add ne može izvršiti prije i . Grafikon objašnjava da će:
- izračunati i:
- dodati 1) zajedno
- dodaj u 2)
- dodati 3) na
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
Objašnjenje koda
- x: Inicijalizirajte varijablu pod nazivom x s konstantnom vrijednošću 5
- z: Inicijalizirajte varijablu nazvanu z konstantnom vrijednošću 6
- c: Inicijalizirajte konstantni tenzor nazvan c konstantnom vrijednošću 5
- kvadrat: Inicijalizirajte konstantni tenzor koji se zove kvadrat s konstantnom vrijednošću 2
- f: Konstruirajte operator
U ovom primjeru odlučili smo zadržati vrijednosti varijabli fiksnima. Također smo stvorili konstantni tenzor nazvan c koji je konstantni parametar u funkciji f. Zauzima fiksnu vrijednost 5. Na grafikonu možete vidjeti ovaj parametar u tenzoru koji se naziva konstanta.
Također smo konstruirali konstantni tenzor za potenciju u operatoru tf.pow(). Nije potrebno. Napravili smo to tako da možete vidjeti naziv tenzora na grafu. To je krug koji se zove kvadrat.
Iz grafikona možete razumjeti što će se dogoditi s tenzorima i kako mogu vratiti rezultat od 66.
Kod u nastavku procjenjuje funkciju u sesiji.
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)
Izlaz
[66]
Rezime
TensorFlow radi oko:
- Grafikon: Računalno okruženje koje sadrži operacije i tenzore
- Tenzori: Predstavlja podatke (ili vrijednosti) koji će teći u grafikonu. To je rub u grafikonu
- sjednice: Dopusti izvođenje operacija
Napravite konstantni tenzor
| konstanta | 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) |
Stvorite operator
| Stvorite operator | Objekt |
|---|---|
| a + b | tf.add(a, b) |
| a*b | tf.multiply(a, b) |
Napravite varijabilni tenzor
| Stvorite varijablu | objekt |
|---|---|
| slučajna vrijednost | tf.get_variable(“var”, [1, 2]) |
| početna prva vrijednost | tf.get_variable(“var_init_2”, dtype=tf.int32, initializer=[ [1, 2], [3, 4] ]) |
Otvorite sesiju
| Sjednica | objekt |
|---|---|
| Stvorite sesiju | tf.Session() |
| Pokrenite sesiju | tf.Session.run() |
| Procijenite tenzor | naziv_varijable.eval() |
| Zatvorite sesiju | sess.close() |
| Sesija po bloku | s tf.Session() kao sess: |
