TensorFlow Noțiuni de bază: Tensor, Shape, Type, Sessions & Operatori

Ce este un tensor?

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

Un tensor poate fi originar 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 calcul care are loc succesiv. Fiecare operație se numește nod op și este conectată una cu cealaltă.

Graficul prezintă opțiunile și conexiunile dintre noduri. Cu toate acestea, nu afișează valorile. Marginea nodurilor este tensorul, adică o modalitate de a completa 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. Vectorul caracteristică va fi de obicei intrarea principală pentru a popula un tensor. Aceste valori vor curge într-un nod op prin tensor și 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ții pot fi vizualizate în grafic.

În acest tutorial, veți învăța elementele de bază TensorFlow cum ar fi-

• Ce este un tensor?
• Reprezentarea unui tensor
• Tipuri de tensori
• Creați un tensor de dimensiune n
• Forma tensorului
• Tipul de date
• Operator de creare
• Unii operatori utili TensorFlow
• Variabile
• Substituent
• Sesiune
• 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 2x3 cu valori de la 1 la 6, scriem:

Reprezentarea unui tensor

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 doar mai complicat să vizualizați un nivel de dimensiune mai înalt.

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 (formă)
• Un tip de date (dtype)

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

• tf.Variabil
• tf.constant
• tf.plasant
• tf.SparseTensor

În acest tutorial, veți învăța cum să creați un tf.constant și un 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 utilizatorul Windows:

activate hello-tf 

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

# Import tfimport tensorflow as tf 

Creați un tensor de dimensiune n

Î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 namer1 = tf.constant(1, tf.int16)print(r1)

Ieșire

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

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

Ieșire

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

Fiecare tensor este afișat cu numele tensorului. Fiecare obiect tensor este definit cu atribute tensoriale precum 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 schimbând tipul de date.

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

Ieșire

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

Un tensor de dimensiunea 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) 

Ieșire

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 din 1 coloană.

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

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

Ieșire

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 parantezele.

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

Ieșire

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

Matricea arată ca imaginea a doua.

Forma tensorului

Când imprimați tensorul, TensorFlow ghicește forma. Cu toate acestea, puteți obține forma tensorului cu proprietatea de formă 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 tensorm_shape = tf.constant([ [10, 11],[12, 13],[14, 15] ])m_shape.shape 

Ieșire

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 0print(tf.zeros(10)) 

Ieșire

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

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

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

Ieșire

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

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

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

Ieșire

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

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

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

Ieșire

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

În cele din urmă, puteți crea o matrice 3x2 numai cu una

print(tf.ones(m_shape.shape)) 

Ieșire

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) 

Ieșire

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

Exemplu

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

Ieșire

TensorFlow alege automat tipul de date 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

Unii operatori utili TensorFlow

Știi cum să creezi un tensor cu TensorFlow. Este timpul să învățăm cum să efectuăm operații matematice.

TensorFlow conține toate operațiunile de bază. Puteți începe cu unul simplu. Veți utiliza 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 plutitor.

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

Ieșire

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

Notă: ieșirea a returnat un obiect tensor și nu rezultatul pătratului de 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.

Următoarea este o listă a operațiilor 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.multiplicați (a, b)
• tf.div (a, b)
• tf.pow (a, b)
• tf.exp (a)
• tf.sqrt (a)

Exemplu

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

Ieșire

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

Adunăm ambii tensori.

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

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

Ieșire

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 utiliza 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. OptionalIf 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 valuesvar = tf.get_variable("var", [1, 2])print(var.shape) 

Ieșire

(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 inițiale ale acestui tensor sunt zero. De exemplu, atunci când instruiț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) 

Ieșire

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

Ieșire

(2, 2) 

Substituent

Un substituent are scopul de a alimenta tensorul. Substituentul este utilizat pentru a inițializa datele pentru a curge î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 următoarea sesiune, 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. Optionaldata_placeholder_a = tf.placeholder(tf.float32, name = "data_placeholder_a")print(data_placeholder_a) 

Ieșire

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

Sesiune

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

• Grafic
• Tensor
• Sesiune

Componente	Descriere
Grafic	Graficul este fundamental în TensorFlow. Toate operațiile matematice (operații) sunt efectuate în interiorul unui grafic. Vă puteți imagina un grafic ca un proiect în care se efectuează fiecare operație. Nodurile reprezintă aceste operațiuni, 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 cadrul 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 pe care să le utilizați ulterior pentru calcule ulterioare.

În exemplul de mai jos, veți:

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

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

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

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

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

Pasul 3) Deschideți o sesiune. Toate calculele se vor întâmpla în cadrul sesiunii. Când ați terminat, trebuie să închideți sesiunea.

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

Ieșire

[8] 

Explicarea codului

• tf.Session (): Deschideți o sesiune. Toate operațiunile vor curge în cadrul sesiunilor
• rulați (multiplicați): executați operația creată la pasul 2.
• print (result_1): În cele din urmă, puteți imprima rezultatul
• close (): Închideți sesiunea

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

Un alt mod 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) 

Ieșire

[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 le-ați creat până acum.

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

Ieșire

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 explicit toate variabilele. Acest lucru este util înainte de a antrena un model.

Puteți verifica valorile variabilelor create 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)) 

Ieșire

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

Puteți utiliza substituentul pe care l-ați creat anterior și îl puteți alimenta cu valoare reală. Trebuie să treceți datele în metoda feed_dict.

De exemplu, veți prelua puterea a 2 din substituentul date_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. 

Explicarea codului

• import numpy ca np: Importați biblioteca 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}: Alimentează substituentul cu date

Ieșire

[[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 efectua operația. Toate calculele sunt reprezentate printr-o schemă de flux de date. Graficul fluxului de date a fost dezvoltat pentru a vedea dependențele de date între operația individuală. Formula matematică sau algoritmul sunt alcătuite dintr-o serie de operații succesive. Un grafic este un mod convenabil de a vizualiza modul în care calculele sunt coordonate.

Graficul prezintă un nod și o margine . Nodul este reprezentarea unei operații, adică unitatea de calcul. Marginea este tensorul, poate produce un nou tensor sau poate consuma datele de intrare. Depinde de dependențele dintre operațiunea individuală.

Structura graficului conectează împreună operațiunile (adică nodurile) și modul în care acestea sunt operațiile sunt alimentate. Rețineți că graficul nu afișează ieșirea operațiilor, ci doar ajută la vizualizarea conexiunii dintre operații 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:

Exemplu TensorFlow Graph

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

De exemplu, puteți vedea operația add nu se poate face înainte și. Graficul explică faptul că:

1. calculează și:
2. adăugați 1) împreună
3. adaugă 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ă menținem valorile variabilelor fixe. 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 din 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 variableswith tf.Session() as sess:init.run() # Initialize x and yfunction_result = f.eval()print(function_result) 

Ieșire

[66] 

rezumat

TensorFlow funcționează în jurul:

• Grafic : mediu de calcul care conține operațiile și tensorii
• Tensori : reprezintă datele (sau valoarea) care vor curge în grafic. Este marginea din grafic
• Sesiuni : permite executarea operațiunilor

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.multiplicați (a, b)

Creați un tensor variabil

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

Deschideți o sesiune

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