TensorFlow pamati: Tensors, forma, tips, sesijas un amp; Operatori

Kas ir tenors?

Tensorflow nosaukums ir tieši atvasināts no tā pamata ietvara: Tensor. Programmā Tensorflow visos aprēķinos ir iesaistīti tenori. Tensors ir n-dimensiju vektors vai matrica, kas attēlo visu veidu datus. Visām tenzora vērtībām ir identisks datu tips ar zināmu (vai daļēji zināmu) formu. Datu forma ir matricas vai masīva izmērs.

Tensoru var iegūt no ievades datiem vai aprēķina rezultāta. Programmā TensorFlow visas darbības tiek veiktas grafika iekšpusē. Grafiks ir aprēķinu kopums, kas notiek secīgi. Katru darbību sauc par op mezglu un tās ir savienotas viena ar otru.

Grafikā ir izklāstītas ops un savienojumi starp mezgliem. Tomēr vērtības netiek parādītas. Mezglu mala ir tenzors, ti, veids, kā aizpildīt operāciju ar datiem.

Mašīnmācībā modeļi tiek baroti ar objektu sarakstu, kurus sauc par funkciju vektoriem. Funkcijas vektors var būt jebkura veida dati. Funkcijas vektors parasti būs primārais ievads tenora aizpildīšanai. Šīs vērtības ieplūdīs op mezglā caur tenoru, un šīs operācijas / aprēķina rezultāts radīs jaunu tenoru, kuru savukārt izmantos jaunā operācijā. Visas šīs darbības var apskatīt diagrammā.

Šajā apmācībā jūs uzzināsiet TensorFlow pamatus, piemēram,

• Kas ir tenors?
• Tensora pārstāvība
• Tensora veidi
• Izveidojiet n-dimensijas tenoru
• Tensora forma
• Datu tips
• Operatora izveide
• Daži noderīgi TensorFlow operatori
• Mainīgie
• Vietnieks
• Sesija
• Grafiks

Tensora pārstāvība

Programmā TensorFlow tenzors ir n-dimensiju vektoru (ti, masīva) kopums. Piemēram, ja mums ir 2x3 matrica ar vērtībām no 1 līdz 6, mēs rakstām:

Tensora pārstāvība

TensorFlow attēlo šo matricu kā:

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

Ja mēs izveidojam trīsdimensiju matricu ar vērtībām no 1 līdz 8, mums ir:

TensorFlow attēlo šo matricu kā:

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

Piezīme . Tensoru var attēlot ar skalāru vai tā forma var būt vairāk nekā trīs dimensijas. Augstākas dimensijas līmeņa vizualizēšana ir tikai sarežģītāka.

Tensora veidi

Programmā TensorFlow visi aprēķini iziet caur vienu vai vairākiem tenzoriem. Tf.tensors ir objekts ar trim īpašībām:

• Unikāla etiķete (nosaukums)
• Dimensija (forma)
• Datu tips (dtype)

Katra darbība, ko veicat ar TensorFlow, ietver manipulācijas ar tenoru. Ir četri galvenie tenzora veidi, kurus varat izveidot:

• tf. Mainīgs
• tf.pastāvīgs
• tf.placeholder
• tf.SparseTensor

Šajā apmācībā jūs uzzināsiet, kā izveidot tf.constant un tf.Variable.

Pirms mēs apmeklējam apmācību, pārliecinieties, ka esat aktivizējis konda vidi ar TensorFlow. Mēs šo vidi nosaucām par hello-tf.

MacOS lietotājam:

source activate hello-tf 

Windows lietotājam:

activate hello-tf 

Pēc tam jūs esat gatavs importēt tensorflow

# Import tfimport tensorflow as tf 

Izveidojiet n-dimensijas tenoru

Jūs sākat ar tenzora izveidi ar vienu dimensiju, proti, skalāru.

Lai izveidotu tenoru, varat izmantot tf.constant (), kā parādīts zemāk esošajā TensorFlow tenzora formas piemērā:

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` 

Lai izveidotu 0 dimensijas tenoru, palaidiet šo kodu

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

Rezultāts

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

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

Rezultāts

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

Katrs tenors tiek parādīts ar tenora nosaukumu. Katrs tenzora objekts tiek definēts ar tensora atribūtiem, piemēram, unikālu etiķeti (nosaukumu), dimensiju (formu) un TensorFlow datu tipiem (dtype).

Tensoru var definēt ar decimāldaļām vai ar virkni, mainot datu veidu.

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

Rezultāts

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

1. dimensijas tenoru var izveidot šādi:

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

Rezultāts

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

Varat pamanīt, ka TensorFlow forma sastāv tikai no 1 kolonnas.

Lai izveidotu 2 tenzora izmēru masīvu, pēc katras rindas ir jāaizver iekavas. Pārbaudiet zemāk redzamo Keras Tensor formas piemēru

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

Rezultāts

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

Matricā ir 2 rindas un 2 kolonnas, kas aizpildītas ar vērtībām 1, 2, 3, 4.

Matrica ar 3 dimensijām tiek izveidota, iekavām pievienojot vēl vienu līmeni.

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

Rezultāts

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

Matrica izskatās pēc otrā attēla.

Tensora forma

Drukājot tenoru, TensorFlow uzminē formu. Tomēr jūs varat iegūt tenzora formu ar TensorFlow formas īpašību.

Zemāk jūs izveidojat matricu, kas piepildīta ar skaitli no 10 līdz 15, un jūs pārbaudāt m_shape formu

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

Rezultāts

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

Matricā ir 3 rindas un 2 kolonnas.

TensorFlow ir noderīgas komandas, lai izveidotu vektoru vai matricu, kas piepildīta ar 0 vai 1. Piemēram, ja vēlaties izveidot 1-D tenzoru ar noteiktu formu 10, kas piepildīts ar 0, varat palaist zemāk esošo kodu:

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

Rezultāts

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

Īpašums darbojas arī matricā. Šeit jūs izveidojat 10x10 matricu, kas piepildīta ar 1

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

Rezultāts

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

Lai izveidotu vektoru, varat izmantot dotās matricas formu. Matrica m_shape ir 3x2 izmēri. Jūs varat izveidot tenzoru ar 3 rindām, kuras aizpilda viena ar šādu kodu:

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

Rezultāts

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

Ja iekavās ievadāt vērtību 1, varat izveidot tādu vektoru, kas ir vienāds ar kolonnu skaitu matricā m_shape.

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

Rezultāts

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

Visbeidzot, jūs varat izveidot matricu 3x2 tikai ar vienu

print(tf.ones(m_shape.shape)) 

Rezultāts

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

Datu tips

Tensora otrā īpašība ir datu tips. Tensoram vienlaikus var būt tikai viena veida dati. Tensoram var būt tikai viena veida dati. Jūs varat atgriezt veidu ar rekvizītu dtype.

print(m_shape.dtype) 

Rezultāts

Dažos gadījumos vēlaties mainīt datu veidu. Programmā TensorFlow tas ir iespējams ar metodi tf.cast.

Piemērs

Zemāk pludiņa tenzors tiek pārvērsts par veselu skaitli, izmantojot izmantoto metodi 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) 

Rezultāts

TensorFlow automātiski izvēlas datu tipu, kad tenisa izveides laikā arguments nav norādīts. TensorFlow uzminēs, kādi ir visticamākie datu veidi. Piemēram, ja jūs nodosiet tekstu, tas uzminēs, ka tā ir virkne, un pārveidos to par virkni.

Operatora izveide

Daži noderīgi TensorFlow operatori

Jūs zināt, kā izveidot tenoru ar TensorFlow. Ir pienācis laiks iemācīties veikt matemātiskas darbības.

TensorFlow satur visas pamatdarbības. Jūs varat sākt ar vienkāršu. Skaitļa kvadrāta aprēķināšanai izmantosiet metodi TensorFlow. Šī darbība ir vienkārša, jo tenzora izveidošanai ir nepieciešams tikai viens arguments.

Skaitļa kvadrātu konstruē ar tf.sqrt (x) ar x kā peldošu skaitli.

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

Rezultāts

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

Piezīme: Izeja atgrieza tenzora objektu, nevis kvadrāta 2 rezultātu. Piemērā jūs drukājat tenzora definīciju, nevis faktisko operācijas novērtējumu. Nākamajā sadaļā jūs uzzināsiet, kā TensorFlow darbojas, lai veiktu operācijas.

Tālāk ir saraksts ar visbiežāk izmantotajām darbībām. Ideja ir tāda pati. Katrai operācijai nepieciešams viens vai vairāki argumenti.

• tf.add (a, b)
• tf. abstrakts (a, b)
• tf. reizināt (a, b)
• tf.div (a, b)
• tf.pow (a, b)
• tf.exp (a)
• tf.sqrt (a)

Piemērs

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

Rezultāts

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

Kods Paskaidrojums

Izveidojiet divus tenorus:

• viens tenors ar 1 un 2
• viens tenors ar 3 un 4

Jūs saskaitāt abus tenorus.

Ievērojiet : abiem tenzoriem jābūt vienādām. Jūs varat veikt reizinājumu pāri diviem tenzoriem.

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

Rezultāts

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

Mainīgie

Līdz šim jūs esat izveidojis tikai pastāvīgus tenorus. Tas nav īpaši noderīgs. Dati vienmēr tiek piegādāti ar dažādām vērtībām, lai to uztvertu, varat izmantot klasi Mainīgais. Tas būs mezgls, kurā vērtības vienmēr mainās.

Lai izveidotu mainīgo, varat izmantot metodi 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. 

Piemēram, zemāk redzamais kods izveido divdimensiju mainīgo ar divām nejaušām vērtībām. Pēc noklusējuma TensorFlow atgriež nejaušu vērtību. Jūs nosaucat mainīgo var

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

Rezultāts

(1, 2) 

Otrajā piemērā jūs izveidojat mainīgo ar vienu rindu un divām kolonnām. Lai izveidotu mainīgā lielumu, jums jāizmanto [1,2]

Šī tenzora iniciāļu vērtības ir nulle. Piemēram, apmācot modeli, jums ir jābūt sākotnējām vērtībām, lai aprēķinātu funkciju svaru. Zemāk jūs iestatāt šo sākotnējo vērtību uz nulli.

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

Rezultāts

(1, 2) 

Mainīgajā var nodot nemainīga tenzora vērtības. Jūs izveidojat pastāvīgu tenzoru ar metodi tf.constant (). Jūs izmantojat šo tenzoru, lai inicializētu mainīgo.

Mainīgā lieluma pirmās vērtības ir 10, 20, 30 un 40. Jaunā tenzora forma būs 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) 

Rezultāts

(2, 2) 

Vietnieks

Vietnieka funkcija ir barot tenoru. Vietnieks tiek izmantots, lai inicializētu datus, kas plūst tenoru iekšienē. Lai piegādātu vietturi, jums jāizmanto metode feed_dict. Vietnieks tiks ievadīts tikai sesijas laikā.

Nākamajā piemērā jūs redzēsiet, kā izveidot vietturi ar metodi tf.placeholder. Nākamajā sesijā jūs iemācīsities ievadīt vietturi ar faktisko tenzora vērtību.

Sintakse ir:

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) 

Rezultāts

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

Sesija

TensorFlow darbojas ap 3 galvenajām sastāvdaļām:

• Grafiks
• Tensors
• Sesija

Komponenti	Apraksts
Grafiks	TensorFlow grafiks ir būtisks. Visas matemātiskās darbības (ops) tiek veiktas grafika iekšpusē. Jūs varat iedomāties grafiku kā projektu, kurā tiek veiktas visas darbības. Mezgli pārstāv šos opus, tie var absorbēt vai radīt jaunus tenorus.
Tensors	Tensors atspoguļo datus, kas progresē starp operācijām. Jūs iepriekš redzējāt, kā inicializēt tenoru. Atšķirība starp nemainīgu un mainīgu ir tā, ka mainīgā sākotnējās vērtības laika gaitā mainīsies.
Sesija	Sesija veiks darbību no diagrammas. Lai diagrammu barotu ar tenzora vērtībām, jāatver sesija. Sesijas laikā jāizveido operators, lai izveidotu izvadi.

Grafiki un sesijas ir neatkarīgas. Jūs varat palaist sesiju un iegūt vērtības, kuras vēlāk izmantot turpmākajiem aprēķiniem.

Tālāk sniegtajā piemērā:

• Izveidojiet divus tenorus
• Izveidojiet operāciju
• Atveriet sesiju
• Izdrukājiet rezultātu

1. solis. Jūs izveidojat divus tenorus x un y

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

2. solis. Jūs izveidojat operatoru, reizinot x un y

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

3. solis. Jūs atverat sesiju. Visi aprēķini notiks sesijas laikā. Kad esat pabeidzis, sesija ir jāaizver.

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

Rezultāts

[8] 

Koda skaidrojums

• tf.Session (): atveriet sesiju. Visas operācijas notiks sesiju laikā
• palaist (reizināt): izpildiet 2. darbībā izveidoto darbību.
• izdrukāt (rezultāts_1): Visbeidzot, jūs varat izdrukāt rezultātu
• aizvērt (): aizveriet sesiju

Rezultāts parāda 8, kas ir x un y reizinājums.

Vēl viens veids, kā izveidot sesiju, ir bloka iekšpusē. Priekšrocība ir tā, ka tā automātiski aizver sesiju.

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

Rezultāts

[8] 

Sesijas kontekstā operācijas veikšanai varat izmantot metodi eval (). Tas ir līdzvērtīgs skriešanai (). Tas padara kodu vieglāk lasāmu.

Varat izveidot sesiju un redzēt vērtības līdz šim izveidotajos tenoros.

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

Rezultāts

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

Mainītāji pēc noklusējuma ir tukši pat pēc tenzora izveides. Ja vēlaties izmantot mainīgo, jums jāinicializē mainīgais. Lai inicializētu mainīgā lielumus, nepieciešams izsaukt objektu tf.global_variables_initializer (). Šis objekts skaidri inicializēs visus mainīgos. Tas ir noderīgi, pirms apmācāt modeli.

Varat pārbaudīt iepriekš izveidoto mainīgo vērtības. Ņemiet vērā, ka tenzora novērtēšanai jāizmanto run

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

Rezultāts

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

Varat izmantot iepriekš izveidoto vietturi un ievadīt to ar faktisko vērtību. Dati jāievada metodē feed_dict.

Piemēram, jūs izmantosiet 2 no viettura data_placeholder_a lielumu.

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. 

Kods Paskaidrojums

• import numpy as np: Importējiet numpy bibliotēku, lai izveidotu datus
• tf.pow (data_placeholder_a, 2): izveidojiet op
• np.random.rand (1, 10): izveidojiet nejaušu datu masīvu
• feed_dict = {data_placeholder_a: data}: barojiet vietturi ar datiem

Rezultāts

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

Grafiks

TensorFlow ir atkarīgs no ģeniālas pieejas operācijas atveidošanai. Visi aprēķini tiek attēloti ar datu plūsmas shēmu. Datu plūsmas diagramma ir izstrādāta, lai pārliecinātos par datu atkarību starp atsevišķām darbībām. Matemātiskā formula vai algoritms tiek veidots no vairākām secīgām darbībām. Grafiks ir ērts veids, kā vizualizēt aprēķinu koordināciju.

Grafikā parādīts mezgls un mala . Mezgls ir operācijas attēlojums, ti, aprēķina vienība. Mala ir tenzors, tā var radīt jaunu tenoru vai patērēt ievades datus. Tas ir atkarīgs no atkarībām starp individuālu darbību.

Grafika struktūra savieno operācijas (ti, mezglus) un to, kā tās darbojas. Ņemiet vērā, ka diagrammā netiek parādīta darbību izlaide, tas tikai palīdz vizualizēt saikni starp atsevišķām operācijām.

Apskatīsim piemēru.

Iedomājieties, ka vēlaties novērtēt šādu funkciju:

TensorFlow izveidos grafiku funkcijas izpildei. Diagramma izskatās šādi:

TensorFlow Graph piemērs

Jūs viegli varat redzēt ceļu, pa kuru tenzori dosies, lai sasniegtu galamērķi.

Piemēram, jūs varat redzēt, ka operāciju pievienot nevar veikt pirms un. Grafikā paskaidrots, ka tas:

1. aprēķināt un:
2. pievienot 1) kopā
3. pievienot 2)
4. pievienot 3)

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 

Kods Paskaidrojums

• x: inicializējiet mainīgo, ko sauc par x, ar nemainīgu vērtību 5
• z: inicializējiet mainīgo, ko sauc par z, ar nemainīgu vērtību 6
• c: inicializējiet nemainīgu tenzoru, ko sauc par c, ar nemainīgu vērtību 5
• kvadrāts: inicializējiet nemainīgu tenzoru, ko sauc par kvadrātu, ar nemainīgu vērtību 2
• f: uzbūvējiet operatoru

Šajā piemērā mēs izvēlamies saglabāt nemainīgas mainīgo vērtības. Mēs arī izveidojām nemainīgu tenzoru ar nosaukumu c, kas ir nemainīgs parametrs funkcijā f. Nepieciešama fiksēta vērtība 5. Grafikā šo parametru var redzēt tenzorā, ko sauc par konstanti.

Mēs arī izveidojām nemainīgu tenzoru operatora tf.pow () jaudai. Tas nav nepieciešams. Mēs to izdarījām, lai diagrammā varētu redzēt tenzora vārdu. Tas ir aplis, ko sauc par kvadrātu.

Pēc diagrammas jūs varat saprast, kas notiks ar tenzoriem un kā tas var atgriezt izeju 66.

Zemāk esošais kods novērtē sesijas funkciju.

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) 

Rezultāts

[66] 

Kopsavilkums

TensorFlow darbojas ap:

• Grafiks : skaitļošanas vide, kurā ir operācijas un tenzori
• Tensori : attēlo datus (vai vērtību), kas plūst diagrammā. Tā ir diagrammas mala
• Sesijas : ļauj veikt operācijas

Izveidojiet pastāvīgu tenzoru

nemainīgs	objekts
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)

Izveidojiet operatoru

Izveidojiet operatoru	Objekts
a + b	tf.add (a, b)
a * b	tf. reizināt (a, b)

Izveidojiet mainīgo tenzoru

Izveidojiet mainīgo	objekts
randomizēta vērtība	tf.get_variable ("var", [1, 2])
inicializēta pirmā vērtība	tf.get_variable ("var_init_2", dtype = tf.int32, inicializētājs = [[1, 2], [3, 4]])

Atveriet sesiju

Sesija	objekts
Izveidojiet sesiju	tf.Sesija ()
Palaidiet sesiju	tf.Session.run ()
Novērtējiet tenoru	mainīgais_nosaukums.eval ()
Aizveriet sesiju	sess.close ()
Sesija pa blokiem	ar tf.Session () kā sess: