Bazele TensorFlow: tensor, formă, tip, sesiuni și Operatori

Ce este un tensor?

Numele Tensorflow este derivat direct din cadrul său de bază: Tensor. În Tensorflow, toate calculele implică tensori. Un tensor este un vector sau o matrice de n dimensiuni care reprezintă toate tipurile de date. Toate valorile dintr-un tensor au un tip de date identic cu o formă cunoscută (sau parțial cunoscută). Forma datelor este dimensionalitatea matricei sau a tabloului.

Un tensor poate fi originat din datele de intrare sau din rezultatul unui calcul. În TensorFlow, toate operațiunile sunt efectuate în interiorul unui grafic. Graficul este un set de calcule care au loc succesiv. Fiecare operație se numește nod operațional și sunt conectate între ele.

Graficul conturează operațiunile și conexiunile dintre noduri. Cu toate acestea, nu afișează valorile. Marginea nodurilor este tensorul, adică o modalitate de a popula operația cu date.

În Machine Learning, modelele sunt alimentate cu o listă de obiecte numite vectori de caracteristici. Un vector caracteristic poate fi de orice tip de date. Vectorul caracteristică va fi de obicei intrarea principală pentru a popula un tensor. Aceste valori vor curge într-un nod operațional prin tensor, iar rezultatul acestei operații/calcul va crea un nou tensor care, la rândul său, va fi utilizat într-o nouă operație. Toate aceste operațiuni pot fi vizualizate în grafic.

Reprezentarea unui tensor

În TensorFlow, un tensor este o colecție de vectori de caracteristici (adică, matrice) de n dimensiuni. De exemplu, dacă avem o matrice 2×3 cu valori de la 1 la 6, scriem:

TensorFlow reprezintă această matrice ca:

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

Dacă creăm o matrice tridimensională cu valori de la 1 la 8, avem:

TensorFlow reprezintă această matrice ca:

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

Notă: Un tensor poate fi reprezentat cu un scalar sau poate avea o formă mai mare de trei dimensiuni. Este mai complicat să vizualizați un nivel de dimensiune mai înalt.

Tipuri de tensori

În TensorFlow, toate calculele trec prin unul sau mai mulți tensori. Un tf.tensor este un obiect cu trei proprietăți:

• O etichetă unică (nume)
• O dimensiune (forma)
• Un tip de date (dtype)

Fiecare operație pe care o vei face cu TensorFlow implică manipularea unui tensor. Există patru tipuri principale de tensori pe care le puteți crea:

• tf.Variabilă
• tf.constant
• tf.substituent
• tf.SparseTensor

În acest tutorial, veți învăța cum să creați o tf.constant și o tf.Variable.

Înainte de a parcurge tutorialul, asigurați-vă că activați mediul conda cu TensorFlow. Am numit acest mediu hello-tf.

Pentru utilizatorul MacOS:

source activate hello-tf

Pentru Windows utilizator:

activate hello-tf

După ce ați făcut asta, sunteți gata să importați tensorflow

# Import tf
import tensorflow as tf

Creați un tensor de n-dimensiune

Începeți cu crearea unui tensor cu o singură dimensiune, și anume un scalar.

Pentru a crea un tensor, puteți utiliza tf.constant() așa cum se arată în exemplul de formă de tensor TensorFlow de mai jos:

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`

Pentru a crea un tensor de dimensiune 0, rulați următorul cod

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

producție

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

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

producție

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

Fiecare tensor este afișat după numele tensorului. Fiecare obiect tensor este definit cu atribute tensor, cum ar fi o etichetă unică (nume), o dimensiune (formă) și tipuri de date TensorFlow (dtype).

Puteți defini un tensor cu valori zecimale sau cu un șir prin schimbarea tipului de date.

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

producție

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

Un tensor de dimensiune 1 poate fi creat după cum urmează:

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

producție

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

Puteți observa că forma TensorFlow este compusă doar dintr-o coloană.

Pentru a crea o matrice de 2 dimensiuni tensoare, trebuie să închideți parantezele după fiecare rând. Verificați exemplul de formă Keras Tensor de mai jos

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

producție

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

Matricea are 2 rânduri și 2 coloane umplute cu valorile 1, 2, 3, 4.

O matrice cu 3 dimensiuni este construită prin adăugarea unui alt nivel cu paranteze.

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

producție

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

Matricea arată ca în imaginea a doua.

Forma tensorului

Când imprimați tensor, TensorFlow ghicește forma. Cu toate acestea, puteți obține forma tensorului cu proprietatea formei TensorFlow.

Mai jos, construiți o matrice umplută cu un număr de la 10 la 15 și verificați forma m_shape

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

producție

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

Matricea are 3 rânduri și 2 coloane.

TensorFlow are comenzi utile pentru a crea un vector sau o matrice umplută cu 0 sau 1. De exemplu, dacă doriți să creați un tensor 1-D cu o formă specifică de 10, umplută cu 0, puteți rula codul de mai jos:

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

producție

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

Proprietatea funcționează și pentru matrice. Aici, creați o matrice de 10×10 umplută cu 1

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

producție

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

Puteți utiliza forma unei matrice date pentru a face un vector de unele. Matricea m_shape are dimensiuni de 3×2. Puteți crea un tensor cu 3 rânduri completate de unul cu următorul cod:

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

producție

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

Dacă treceți valoarea 1 în paranteză, puteți construi un vector de unități egal cu numărul de coloane din matricea m_shape.

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

producție

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

În cele din urmă, puteți crea o matrice 3×2 doar cu una

print(tf.ones(m_shape.shape))

producție

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

Tipul de date

A doua proprietate a unui tensor este tipul de date. Un tensor poate avea un singur tip de date la un moment dat. Un tensor poate avea un singur tip de date. Puteți returna tipul cu proprietatea dtype.

print(m_shape.dtype)

producție

<dtype: 'int32'>

În unele ocazii, doriți să schimbați tipul de date. În TensorFlow, este posibil cu metoda tf.cast.

Exemplu

Mai jos, un tensor flotant este convertit în număr întreg folosind metoda 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)

producție

<dtype: 'float32'>
<dtype: 'int32'>

TensorFlow alege tipul de date automat atunci când argumentul nu este specificat în timpul creării tensorului. TensorFlow va ghici care sunt cele mai probabile tipuri de date. De exemplu, dacă treceți un text, acesta va ghici că este un șir și îl va converti în șir.

Operator de creare

Câțiva operatori TensorFlow utili

Știi cum să creezi un tensor cu TensorFlow. Este timpul să învățați cum să efectuați operații matematice.

TensorFlow conține toate operațiunile de bază. Puteți începe cu unul simplu. Veți folosi metoda TensorFlow pentru a calcula pătratul unui număr. Această operație este simplă deoarece este necesar un singur argument pentru a construi tensorul.

Pătratul unui număr este construit cu tf.sqrt(x) cu x ca număr flotant.

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

producție

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

Notă: Ieșirea a returnat un obiect tensor și nu rezultatul pătratului lui 2. În exemplu, imprimați definiția tensorului și nu evaluarea efectivă a operației. În secțiunea următoare, veți afla cum funcționează TensorFlow pentru a executa operațiunile.

Mai jos este o listă a operațiunilor utilizate în mod obișnuit. Ideea este aceeași. Fiecare operație necesită unul sau mai multe argumente.

• tf.add(a, b)
• tf.substract(a, b)
• tf.multiplicare(a, b)
• tf.div(a, b)
• tf.pow(a, b)
• tf.exp(a)
• tf.sqrt(a)

Exemplu

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

producție

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

Explicarea codului

Creați doi tensori:

• un tensor cu 1 și 2
• un tensor cu 3 și 4

Aduni ambii tensori.

Observa: că ambii tensori trebuie să aibă aceeași formă. Puteți executa o înmulțire peste cei doi tensori.

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

producție

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

Variabile

Până acum, ați creat doar tensori constanți. Nu este de mare folos. Datele ajung întotdeauna cu valori diferite, pentru a captura acest lucru, puteți folosi clasa Variable. Va reprezenta un nod în care valorile se schimbă întotdeauna.

Pentru a crea o variabilă, puteți utiliza metoda 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.

De exemplu, codul de mai jos creează o variabilă bidimensională cu două valori aleatorii. În mod implicit, TensorFlow returnează o valoare aleatorie. Numiți variabila var

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

producție

(1, 2)

În al doilea exemplu, creați o variabilă cu un rând și două coloane. Trebuie să utilizați [1,2] pentru a crea dimensiunea variabilei

Valorile initiale ale acestui tensor sunt zero. De exemplu, atunci când antrenați un model, trebuie să aveți valori inițiale pentru a calcula greutatea caracteristicilor. Mai jos, setați aceste valori inițiale la zero.

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

producție

(1, 2)

Puteți trece valorile unui tensor constant într-o variabilă. Creați un tensor constant cu metoda tf.constant(). Folosiți acest tensor pentru a inițializa variabila.

Primele valori ale variabilei sunt 10, 20, 30 și 40. Noul tensor va avea o formă de 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)

producție

(2, 2)

Înlocuitor

Un substituent are scopul de a alimenta tensorul. Substituentul este folosit pentru a inițializa datele să curgă în interiorul tensoarelor. Pentru a furniza un substituent, trebuie să utilizați metoda feed_dict. Substituentul va fi alimentat numai în cadrul unei sesiuni.

În exemplul următor, veți vedea cum să creați un substituent cu metoda tf.placeholder. În sesiunea următoare, veți învăța să alimentați un substituent cu valoarea tensorului real.

Sintaxa este:

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)

producție

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

Sesiune

TensorFlow funcționează în jurul a 3 componente principale:

• Grafic
• tensor
• Sesiune

Componente	descritption
Grafic	Graficul este fundamental în TensorFlow. Toate operațiile matematice (ops) sunt efectuate în interiorul unui grafic. Vă puteți imagina un grafic ca un proiect în care sunt efectuate toate operațiunile. Nodurile reprezintă aceste operațiuni, ele pot absorbi sau crea noi tensori.
tensor	Un tensor reprezintă datele care progresează între operații. Ați văzut anterior cum să inițializați un tensor. Diferența dintre o constantă și o variabilă este că valorile inițiale ale unei variabile se vor schimba în timp.
Sesiune	O sesiune va executa operația din grafic. Pentru a alimenta graficul cu valorile unui tensor, trebuie să deschideți o sesiune. În interiorul unei sesiuni, trebuie să rulați un operator pentru a crea o ieșire.

Graficele și sesiunile sunt independente. Puteți rula o sesiune și puteți obține valorile pentru a le utiliza mai târziu pentru calcule ulterioare.

În exemplul de mai jos, veți:

• Creați doi tensori
• Creați o operațiune
• Deschide o sesiune
• Imprimați rezultatul

Pas 1) Creați doi tensori x și y

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

Pas 2) Creați operatorul înmulțind x și y

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

Pas 3) Deschizi o sesiune. Toate calculele vor avea loc în cadrul sesiunii. Când ați terminat, trebuie să închideți sesiunea.

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

producție

[8]

Explicația codului

• tf.Session(): Deschide o sesiune. Toate operațiunile vor decurge în cadrul sesiunilor
• run(multiply): executați operația creată la pasul 2.
• print(result_1): În sfârșit, puteți imprima rezultatul
• close(): Închideți sesiunea

Rezultatul arată 8, care este înmulțirea lui x și y.

O altă modalitate de a crea o sesiune este în interiorul unui bloc. Avantajul este că închide automat sesiunea.

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

producție

[8]

Într-un context al sesiunii, puteți utiliza metoda eval() pentru a executa operația. Este echivalent cu run(). Face codul mai lizibil.

Puteți crea o sesiune și puteți vedea valorile din interiorul tensorilor pe care i-ați creat până acum.

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

producție

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

Variabilele sunt goale în mod implicit, chiar și după ce creați un tensor. Trebuie să inițializați variabila dacă doriți să utilizați variabila. Obiectul tf.global_variables_initializer() trebuie apelat pentru a inițializa valorile unei variabile. Acest obiect va inițializa în mod explicit toate variabilele. Acest lucru este util înainte de a antrena un model.

Puteți verifica valorile variabilelor pe care le-ați creat anterior. Rețineți că trebuie să utilizați run pentru a evalua tensorul

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

producție

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

Puteți folosi substituentul creat anterior și îl puteți alimenta cu valoarea reală. Trebuie să treceți datele în metoda feed_dict.

De exemplu, veți lua puterea lui 2 din substituentul 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.

Explicarea codului

• import numpy ca np: import bibliotecă numpy pentru a crea datele
• tf.pow(data_placeholder_a, 2): Creați operațiunile
• np.random.rand(1, 10): Creați o matrice aleatorie de date
• feed_dict={data_placeholder_a: data}: Alimentați substituentul cu date

producție

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

Grafic

TensorFlow depinde de o abordare genială pentru a reda operația. Toate calculele sunt reprezentate cu o schemă de flux de date. Graficul fluxului de date a fost dezvoltat pentru a vedea dependențele de date între operațiunile individuale. Formula sau algoritmul matematic sunt alcătuiți dintr-un număr de operații succesive. Un grafic este o modalitate convenabilă de a vizualiza modul în care sunt coordonate calculele.

Graficul arată a nod si un margine. Nodul este reprezentarea unei operații, adică unitatea de calcul. Muchia este tensorul, poate produce un nou tensor sau poate consuma datele de intrare. Depinde de dependențele dintre operațiunile individuale.

Structura graficului conectează între ele operațiunile (adică nodurile) și modul în care acestea funcționează sunt alimentate. Rețineți că graficul nu afișează rezultatul operațiunilor, ci ajută doar la vizualizarea conexiunii dintre operațiuni individuale.

Să vedem un exemplu.

Imaginați-vă că doriți să evaluați următoarea funcție:

TensorFlow va crea un grafic pentru a executa funcția. Graficul arată astfel:

Puteți vedea cu ușurință calea pe care o vor parcurge tensorii pentru a ajunge la destinația finală.

De exemplu, puteți vedea că operația de adăugare nu poate fi făcută înainte și . Graficul explică că va:

1. calculează și:
2. adunați 1) împreună
3. adauga la 2)
4. adăugați 3) la

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

Explicarea codului

• x: Inițializați o variabilă numită x cu o valoare constantă de 5
• z: Inițializați o variabilă numită z cu o valoare constantă de 6
• c: Inițializați un tensor constant numit c cu o valoare constantă de 5
• pătrat: Inițializați un tensor constant numit pătrat cu o valoare constantă de 2
• f: Construiți operatorul

În acest exemplu, alegem să păstrăm fixe valorile variabilelor. De asemenea, am creat un tensor constant numit c care este parametrul constant în funcția f. Este nevoie de o valoare fixă ​​de 5. În grafic, puteți vedea acest parametru în tensorul numit constant.

De asemenea, am construit un tensor constant pentru puterea în operatorul tf.pow(). Nu este necesar. Am făcut-o astfel încât să puteți vedea numele tensorului în grafic. Este cercul numit pătrat.

Din grafic, puteți înțelege ce se va întâmpla cu tensorii și cum poate returna o ieșire de 66.

Codul de mai jos evaluează funcția într-o sesiune.

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)

producție

[66]

Rezumat

TensorFlow functioneaza in jurul:

• Grafic: Mediu de calcul care contine operatiile si tensorii
• Tensori: Reprezintă datele (sau valoarea) care vor curge în grafic. Este marginea din grafic
• Sesiuni: Permite executarea operatiunilor

Creați un tensor constant

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

Creați un operator

Creați un operator	Obiect
a + b	tf.add(a, b)
a * b	tf.multiplicare(a, b)

Creați un tensor variabil

Creați o variabilă	obiect
valoare randomizată	tf.get_variable(„var”, [1, 2])
prima valoare initializata	tf.get_variable(„var_init_2”, dtype=tf.int32, initializer=[ [1, 2], [3, 4] ])

Deschide o sesiune

Sesiune	obiect
Creați o sesiune	tf.Session()
Rulați o sesiune	tf.Session.run()
Evaluați un tensor	nume_variabilă.eval()
Închideți o sesiune	sess.close()
Sesiune cu bloc	cu tf.Session() ca sess: