Ce este un Tensor în TensorFlow? Formă, Tip și Operatori

Ce este un tensor?

Numele TensorFlow este derivat direct din obiectul său principal: tensorul. În TensorFlow, fiecare calcul implică tensori. Un tensor este un vector sau o matrice de n dimensiuni care reprezintă toate tipurile de date. Toate valorile dintr-un tensor dețin un tip de date identic cu o formă cunoscută (sau parțial cunoscută), iar forma datelor este dimensionalitatea matricei sau tabloului.

Un tensor poate proveni din datele de intrare sau din rezultatul unui calcul. În TensorFlow, toate operațiile sunt efectuate în interiorul unui graf. Graful este un set de calcule care au loc succesiv. Fiecare operație se numește nod op, iar nodurile sunt conectate între ele.

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

În învățarea automată, modelele sunt alimentate cu o listă de obiecte numite vectori de caracteristici. Un vector de caracteristici poate fi de orice tip de date și este de obicei intrarea principală care populează un tensor. Aceste valori curg într-un nod operațional prin intermediul tensorului, iar rezultatul acelei operații creează un nou tensor, care la rândul său este utilizat într-o nouă operație. Toate aceste operații pot fi vizualizate în grafic.

Reprezentarea unui tensor

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

TensorFlow reprezintă această matrice ca:

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

Dacă creăm o matrice tridimensională cu valori de la 1 la 8, aceleași date sunt desenate ca o casetă cu două fețe suprapuse:

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ă de mai mult de trei dimensiuni. Pur și simplu este mai dificil de vizualizat nivelurile de dimensiune superioare.

Tipuri de tensori

În TensorFlow, toate calculele trec printr-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țiune pe care o efectuați cu TensorFlow implică manipularea unui tensor. Există patru tipuri principale de tensori pe care îi puteți crea:

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

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

Un aspect de reținut înainte de a rula codul: acest tutorial urmează API-ul original TensorFlow 1.x, unde un grafic este construit mai întâi și executat ulterior în cadrul unei sesiuni. TensorFlow 2 rulează cu nerăbdare în mod implicit, așa că mai multe dintre simbolurile de mai jos au fost mutate sau eliminate. Fiecare dintre ele este încă accesibil prin tf.compat.v1 spațiu de nume, iar tabelul mapează fiecare la omologul său modern.

Înainte de a parcurge tutorialul, asigură-te că activezi mediul conda în care este instalat TensorFlow. Acest mediu se numește hello-tf.

Pentru macOS utilizatori:

source activate hello-tf

Pentru Windows utilizatori:

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ă tensorică 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, executați următorul cod.

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

producție

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

Cele trei părți ale acelei ieșiri se corelează cu cele trei proprietăți tensoriale, așa cum arată clar versiunea adnotată de mai jos.

De asemenea, puteți da tensorului un nume propriu cu name a susținut.

# 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 său tensorial. Fiecare obiect tensorial este definit cu atribute precum o etichetă unică (nume), o dimensiune (formă) și un tip 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 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)

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ă dintr-o singură coloană.

Pentru a crea o matrice cu 2 dimensiuni tensoriale, trebuie să închideți parantezele după fiecare rând. Consultați exemplul de formă tensorică 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 și 4.

O matrice cu 3 dimensiuni se construiește prin adăugarea unui alt nivel de 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)

Rezultatul corespunde diagramei tridimensionale de tip cutie prezentate anterior în acest tutorial.

Forma tensorului

Când imprimați un tensor, TensorFlow deduce forma. Cu toate acestea, puteți citi forma direct cu TensorFlow. shape proprietate.

Mai jos, construiești o matrice umplută cu numerele de la 10 la 15 și verifici forma acesteia. 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 o 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)

Poți folosi forma unei matrice date pentru a crea un vector de unități. Matricea m_shape are dimensiuni 3×2, deci următorul cod creează un tensor cu 3 rânduri umplute cu numere de unități:

# 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ă, construiți un vector de unități egal cu numărul de coloane din matrice. 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 de 3×2 umplută în întregime cu numere de unități.

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 conține un singur tip de date la un moment dat și puteți citi acel tip cu dtype proprietate.

print(m_shape.dtype)

producție

<dtype: &#x27;int32'>

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

Exemplu

Mai jos, un tensor cu număr în număr de float este convertit într-un număr întreg cu cast metodă.

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

TensorFlow alege automat tipul de date atunci când argumentul nu este specificat în timpul creării tensorului. TensorFlow ghicește cel mai probabil tip de date: dacă transmiteți text, de exemplu, deduce un șir de caractere.

Crearea OperaTdR

Câteva TensorFlow utile Operatori

Ș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țiile de bază. Poți începe cu una simplă și poți utiliza o metodă TensorFlow pentru a calcula rădăcina pătrată a unui număr. Această operație este simplă deoarece este necesar un singur argument pentru a construi tensorul.

Rădăcina pătrată a unui număr se construiește cu tf.sqrt(x), cu x ca număr în virgulă mobilă.

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

producție

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

Notă: Rezultatul a returnat un obiect tensorial și nu rădăcina pătrată a lui 2. În acest exemplu, imprimați definiția tensorului și nu evaluarea propriu-zisă a operației. În secțiunea Sesiune de mai jos, veți afla cum execută TensorFlow operațiile.

Mai jos este o listă de operații utilizate în mod obișnuit. Ideea este aceeași: fiecare operație necesită unul sau mai multe argumente.

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

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)

Code Explicație

Creați doi tensori:

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

Aduni ambii tensori.

Observați că ambii tensori trebuie să aibă aceeași formă. De asemenea, 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, ceea ce are o utilizare limitată în sine. Datele sosesc întotdeauna cu valori diferite, iar pentru a le captura puteți utiliza clasa Variable. O variabilă reprezintă un nod ale cărui valori se schimbă în timp.

Pentru a crea o variabilă, puteți utiliza tf.get_variable() metodă.

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. Denumiț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 acest exemplu, creați o variabilă cu un rând și două coloane, deci transmiteți [1, 2] ca dimensiune a variabilei.

Valorile inițiale ale unui tensor pot fi, de asemenea, zero. De exemplu, atunci când antrenezi un model, ai nevoie de valori inițiale înainte de a calcula ponderea caracteristicilor. Mai jos, setezi acele 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)

De asemenea, puteți transmite valorile unui tensor constant într-o variabilă. Creați un tensor constant cu metoda tf.constant() și folosiți acel tensor pentru a inițializa variabila.

Primele valori ale variabilei sunt 10, 20, 30 și 40. Noul tensor are forma 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)

producție

(2, 2)

Înlocuitor

Un substituent are scopul de a alimenta tensorul. Un substituent inițializează datele care vor curge în interiorul tensorilor. Pentru a furniza un substituent, utilizați feed_dict argument, iar substituentul este alimentat doar în cadrul unei sesiuni.

În exemplul următor, veți vedea cum să creați un substituent cu metoda tf.placeholderÎn secțiunea Sesiune, veți învăța să alimentați un substituent cu o valoare tensorală 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

Graficele și sesiunile sunt independente. Puteți rula o sesiune și păstra valorile 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

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

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

Pasul 2) Operatorul se creează prin înmulțirea lui x și y

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

Pasul 3) Deschideți o sesiune. Toate calculele au loc în cadrul sesiunii, iar când ați terminat trebuie să o închideți.

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

producție

[8]

Code explicație

• tf.Session()Deschideți o sesiune. Toate operațiunile se desfășoară în cadrul sesiunii.
• run(multiply): execută operația creată la pasul 2
• print(result_1)În final, 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ă sesiunea se închide automat.

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

producție

[8]

În contextul unei sesiuni, puteți utiliza eval() metodă de executare a operației. Este echivalentă cu run() și 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 tensorul. Trebuie să inițializați o variabilă înainte de a o putea utiliza. Obiectul tf.global_variables_initializer() este apelată pentru a inițializa valorile fiecărei variabile simultan, ceea ce este util înainte de a antrena un model.

Poți verifica valorile variabilelor pe care le-ai creat anterior. Reține că trebuie să folosești funcția „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]]

Poți folosi provizoriul creat anterior și să-i adaugi o valoare reală. Trebuie să transmiți datele în feed_dict a susținut.

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.

Code Explicație

• import numpy as np: importați NumPy bibliotecă pentru crearea datelor
• 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 redă fiecare operație cu o schemă de flux de date. Graficul fluxului de date a fost conceput pentru a expune dependențele de date dintre operațiile individuale. O formulă matematică sau un algoritm este alcătuit dintr-un număr de operații succesive, iar un grafic este o modalitate convenabilă de a vizualiza modul în care sunt coordonate aceste calcule.

Graficul prezintă noduri și muchii. Un nod este reprezentarea unei operații, adică unitatea de calcul. O muchie este tensorul: poate produce un nou tensor sau poate consuma datele de intrare, în funcție de dependențele dintre operațiile individuale.

Structura graficului conectează operațiile (adică nodurile) între ele și arată cum este alimentată fiecare dintre ele. Rețineți că graficul nu afișează rezultatul operațiilor; acesta ajută doar la vizualizarea conexiunilor dintre ele.

Să vedem un exemplu. Imaginați-vă că doriți să evaluați următoarea funcție:

TensorFlow construiește 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, add nodul nu poate rula înaintea ambelor Mul și Pow și-au produs rezultatele. Graficul arată că TensorFlow va:

1. calculează x·z în Mul nod și x² în Pow nod
2. adunați aceste două rezultate în add nod
3. adăugați z la acea sumă în add_1 nod
4. adăugați constanta 5 în add_2 nod

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 Explicație

• 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, valorile variabilelor sunt menținute fixe. Tensorul constant c este parametrul constant în funcția f și ia valoarea fixă ​​5; în grafic puteți vedea acest parametru în tensorul numit constantă.

De asemenea, a fost creat un tensor constant pentru puterea din operator tf.pow()Nu este necesar, dar înseamnă că exponentul apare în grafic sub forma unui cerc numit pătrat.

Din grafic, puteți urmări ce se întâmplă cu tensorii și de ce funcția returnează 66: 5 × 6 plus 5² plus 6 plus 5 egal cu 66.

Codul de mai jos evaluează funcția în cadrul unei sesiuni.

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]

Referință rapidă pentru noțiunile de bază despre TensorFlow

Cele patru tabele de mai jos colectează fiecare comandă utilizată în acest tutorial, astfel încât să puteți căuta una fără a derula înapoi prin exemple.

Creați un tensor constant

Creați un operator

Creați un tensor variabil

Deschide o sesiune

Întrebări frecvente