Ce este TensorFlow? Cum funcționează Architectură și caracteristici

Ce este TensorFlow?

TensorFlow este o platformă open-source end-to-end pentru crearea de aplicații de învățare automată. Este o bibliotecă matematică simbolică care utilizează fluxul de date și programarea diferențiabilă pentru a efectua diverse sarcini axate pe antrenament și deducere a rețelelor neuronale profunde. Permite dezvoltatorilor să creeze aplicații de învățare automată folosind diverse instrumente, biblioteci și resurse comunitare.

În prezent, cea mai faimoasă bibliotecă de deep learning din lume este GoogleTensorFlow-ul lui. Google aplică învățarea automată în toate produsele sale pentru a îmbunătăți căutarea, traducerea, subtitrările imaginilor și recomandările.

Exemplu TensorFlow

Pentru a da un exemplu concret, Google Utilizatorii pot experimenta o experiență de căutare mai rapidă și mai rafinată cu ajutorul inteligenței artificiale. Dacă utilizatorul introduce un cuvânt cheie în bara de căutare, Google oferă o recomandare despre care ar putea fi următorul cuvânt.

Google dorește să utilizeze învățarea automată pentru a profita de seturile lor masive de date și a oferi utilizatorilor cea mai bună experiență. Trei grupuri diferite utilizează învățarea automată:

• Cercetatorii
• Oamenii de știință de date
• Programatorii

Toți pot folosi același set de instrumente pentru a colabora între ei și pentru a-și îmbunătăți eficiența.

Google nu doar deține seturi mari de date, ci rulează și o infrastructură de calcul enormă, așa că TensorFlow a fost construit pentru a fi scalabil încă de la început. TensorFlow este o bibliotecă dezvoltată de Google Brain Team va accelera învățarea automată și cercetarea rețelelor neuronale profunde.

A fost construit pentru a rula pe mai multe procesoare sau GPU-uri și chiar pe sisteme de operare mobile și are mai multe wrapper-uri în mai multe limbi, cum ar fi Python, C++ or Java.

Istoria TensorFlow

Acum câțiva ani, deep learning-ul a început să depășească toți ceilalți algoritmi de machine learning atunci când furnizau o cantitate masivă de date. Google a văzut că poate folosi aceste rețele neuronale profunde pentru a-și îmbunătăți serviciile:

• Gmail
• Fotografie
• Google motor de cautare

Au construit un cadru numit TensorFlow astfel încât cercetătorii și dezvoltatorii să poată lucra pe același model, apoi să îl implementeze la o scară pe care mulți oameni ar putea-o utiliza.

TensorFlow a fost lansat public în noiembrie 2015, iar versiunea 1.0 a urmat în februarie 2017. Schimbarea mult mai mare a venit odată cu TensorFlow 2.0 în septembrie 2019, care a făcut ca execuția rapidă să fie implicită și a adoptat Keras ca API standard de nivel înalt. De la versiunea 2.16 încoace, Keras 3 este implicit, iar același cod model poate rula și pe JAX sau Py.Torbackend-uri ch.

TensorFlow este lansat sub licența Apache 2.0, deci îl puteți utiliza, modifica și redistribui, inclusiv comercial, fără a plăti. Google.

Cum funcționează TensorFlow

TensorFlow vă permite să construiți grafice și structuri de flux de date pentru a defini modul în care datele se mișcă printr-un grafic, luând intrările ca o matrice multidimensională numită Tensor. Vă permite să construiți o diagramă de operații care pot fi efectuate pe aceste intrări, care merge la un capăt și vine la celălalt capăt ca ieșire.

TensorFlow Architectură

Arhitectura TensorFlow funcționează în trei părți:

• Preprocesarea datelor
• Construiți modelul
• Antrenați și estimați modelul

Se numește TensorFlow deoarece primește date de intrare sub forma unei matrice multidimensionale, cunoscută și sub numele de tensori. Puteți construi un fel de organigrame de operațiuni (numite Grafic) pe care doriți să le efectuați cu acea intrare. Intrarea intră la un capăt și apoi trece prin acest sistem de operații multiple și iese la celălalt capăt ca ieșire.

Unde poate rula TensorFlow?

Cerințele hardware și software pentru TensorFlow se împart în două faze:

Faza de dezvoltare: acesta este momentul în care antrenezi modelul, de obicei pe un desktop sau laptop.

Faza de rulare sau inferențăOdată ce antrenamentul este complet, modelul poate rula pe mai multe platforme:

• Desktop rulează Windows, macOS sau Linux
• Cloud ca serviciu web
• Dispozitive mobile precum iOS și Android

Îl puteți antrena pe mai multe mașini, apoi îl puteți rula pe o altă mașină, odată ce aveți modelul antrenat.

Modelul poate fi antrenat și utilizat atât pe GPU-uri, cât și pe procesoare. GPU-urile au fost inițial concepute pentru jocuri video. În jurul anului 2009, cercetătorii de la Stanford au arătat că GPU-urile sunt extrem de eficiente la operațiile de matrice și algebră liniară de care depind rețelele neuronale. Învățarea profundă se bazează în mare măsură pe înmulțirea matricelor. TensorFlow este foarte rapid la calcularea înmulțirii matricelor, deoarece este scris în C++. Deși este implementat în C++, TensorFlow poate fi accesat și controlat în principal prin alte limbi, Python.

O altă caracteristică semnificativă este TensorBoard, care vizualizează graficul, metricile de antrenament și distribuția ponderilor în timp ce modelul rulează.

Componentele TensorFlow

tensor

Numele TensorFlow este derivat direct din cadrul său de bază: tensorÎn TensorFlow, toate calculele implică tensori. Un tensor este un vector or matrice de n-dimensiuni care reprezintă toate tipurile de date. Toate valorile dintr-un tensor dețin un tip de date identic cu un cunoscut (sau parțial cunoscut) forma. 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 an nodul op ș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.

graficele

TensorFlow folosește un cadru grafic. Graficul adună și descrie toate calculele serie efectuate în timpul antrenamentului. Graficul are multe avantaje:

• Rulează pe mai multe procesoare sau GPU-uri și chiar și pe sisteme de operare mobile
• Portabilitatea graficului permite păstrarea calculelor pentru utilizare imediată sau ulterioară. Graficul poate fi salvat pentru a fi executat în viitor.
• Toate calculele din grafic sunt realizate prin conectarea tensoarelor
  • Un graf are noduri și muchii. Fiecare nod efectuează o operație matematică și produce o ieșire, în timp ce muchiile descriu relațiile de intrare și ieșire dintre noduri. Tensorii înșiși se deplasează de-a lungul muchiilor.

De ce este TensorFlow popular?

TensorFlow este adoptat pe scară largă deoarece este accesibil la orice nivel de expertiză. API-urile sale acoperă totul, de la un model Keras cu trei linii până la un CNN sau RNN construit manual. Deoarece calculul este exprimat sub formă de grafic, TensorBoard poate vizualiza rețeaua și poate facilita mult depanarea. De asemenea, se implementează la scară largă, rulând pe CPU, GPU și TPU, și pe mobil prin TensorFlow Lite.

TensorFlow rămâne unul dintre cele mai utilizate două framework-uri de deep learning de pe GitHub, alături de Py.Torch.

TensorFlow Algorithms

TensorFlow este livrat cu estimatori de nivel înalt pentru mai mulți algoritmi clasici. În TensorFlow 1.x, aceștia se aflau sub tf.estimator:

• Regresie liniară: tf.estimator.LinearRegressor
• Clasificare: tf.estimator.LinearClassifier
• Clasificare de deep learning: tf.estimator.DNNClassifier
• Învățare extinsă și profundă: tf.estimator.DNNLinearCombinedClassifier
• Regresie arborescentă amplificată: tf.estimator.BoostedTreesRegressor
• Clasificare arborescentă îmbunătățită: tf.estimator.BoostedTreesClassifier

TensorFlow vs. PyTorcap: Pe care ar trebui să o alegi?

TensorFlow și PyTorch sunt cele două framework-uri dominante de deep learning, iar diferențele practice s-au redus considerabil de când TensorFlow 2.0 a adoptat execuția rapidă.

Răspunsul pragmatic: alegeți TensorFlow atunci când modelul trebuie să fie livrat pe mobil, browser sau o stivă de servire gestionată și alegeți Py.Torch atunci când iterezi pe arhitectura modelului. Keras 3, implicit de la TensorFlow 2.16 încoace, simplifică și mai mult decizia, deoarece același cod Keras poate rula pe TensorFlow, JAX sau PyTorch backend.

Cum funcționează calculele în TensorFlow

import numpy as np
import tensorflow as tf

În primele două rânduri de cod, am importat tensorflow ca tf. Cu Python, este o practică obișnuită să folosiți un nume scurt pentru o bibliotecă. Avantajul este să evităm să introducem numele complet al bibliotecii atunci când trebuie să o folosim. De exemplu, putem importa tensorflow ca tf și apelăm tf atunci când dorim să folosim o funcție tensorflow

Să exersăm fluxul de lucru elementar al TensorFlow cu exemple simple de TensorFlow. Să creăm un grafic computațional care înmulțește două numere.

În exemplu, vom înmulți X_1 și X_2. TensorFlow va crea un nod pentru a conecta operația. În exemplul nostru, aceasta se numește înmulțire. După ce graficul este determinat, motoarele de calcul TensorFlow vor înmulți X_1 și X_2.

În cele din urmă, vom rula o sesiune TensorFlow care va rula graficul de calcul cu valorile lui X_1 și X_2 și va imprima rezultatul înmulțirii.

Să definim nodurile de intrare X_1 și X_2. Când creăm un nod în TensorFlow, trebuie să alegem ce tip de nod să creăm. Nodurile X1 și X2 vor fi noduri substituente. Substituentul atribuie o valoare nouă de fiecare dată când efectuăm un calcul. Le vom crea ca noduri substituente TF dot.

Pasul 1: Definiți variabila

X_1 = tf.placeholder(tf.float32, name = "X_1")
X_2 = tf.placeholder(tf.float32, name = "X_2")

Un substituent necesită un tip de date. Acestea sunt numere, deci tf.float32 este alegerea corectă. Argumentul `name` este opțional, dar util, deoarece este eticheta care apare în vizualizarea graficului în TensorBoard. `X_2` este definit în același mod.

Pasul 2: Definiți calculul

multiply = tf.multiply(X_1, X_2, name = "multiply")

Acum putem defini nodul care efectuează operația de multiplicare. În TensorFlow putem face acest lucru prin crearea unui nod tf.multiply.

Vom trece în nodurile X_1 și X_2 la nodul de multiplicare. Îi spune tensorflow să conecteze acele noduri în graficul de calcul, așa că îi cerem să extragă valorile din x și y și să înmulțească rezultatul. Să dăm și nodului de înmulțire numele multiplicare. Este întreaga definiție pentru graficul nostru simplu de calcul.

Pasul 3: Executați operația

Pentru a executa operații în grafic, trebuie să creăm o sesiune. În TensorFlow, acest lucru se face cu ajutorul metodei tf.Session(). Acum, că avem o sesiune, putem solicita sesiunii să execute operații pe graficul nostru computațional apelând metoda session. Pentru a rula calculul, trebuie să folosim metoda run.

Când operația de multiplicare rulează, aceasta are nevoie de valorile nodurilor X_1 și X_2, astfel încât acestea să fie introduse la momentul execuției. Putem face acest lucru prin furnizarea unui parametru numit feed_dict. Transmitem valorile 1,2,3 pentru X_1 și 4,5,6 pentru X_2.

Imprimăm rezultatele cu print(rezultat). Ar trebui să vedem 4, 10 și 18 pentru 1×4, 2×5 și 3×6

X_1 = tf.placeholder(tf.float32, name = "X_1")
X_2 = tf.placeholder(tf.float32, name = "X_2")

multiply = tf.multiply(X_1, X_2, name = "multiply")

with tf.Session() as session:
    result = session.run(multiply, feed_dict={X_1:[1,2,3], X_2:[4,5,6]})
    print(result)

[ 4. 10. 18.]

Opțiuni de încărcare a datelor în TensorFlow

Primul pas înainte de antrenament a algoritmul de învățare automată este de a încărca datele. Există două metode comune de încărcare a datelor:

1. Încărcați datele în memorieEste cea mai simplă metodă. Încărcați toate datele în memorie ca o singură matrice. Scrieți simplu Python pentru asta; nimic din toate acestea nu este specific TensorFlow.

2. Conductă de date TensorFlowTensorFlow oferă o API încorporată care încarcă datele, aplică transformări și alimentează modelul. Această metodă funcționează foarte bine mai ales atunci când aveți un set de date mare. De exemplu, înregistrările de imagini sunt cunoscute ca fiind enorme și nu încap în memorie. Canalul de date gestionează memoria singură.

Ce solutie sa folosesti?

Încărcați datele în memorie

Dacă setul de date nu este prea mare, adică mai puțin de 10 gigaocteți, puteți utiliza prima metodă. Datele se pot încadra în memorie. Puteți folosi o bibliotecă faimoasă numită Pandas pentru a importa fișiere CSV. Veți afla mai multe despre panda în următorul tutorial.

Încărcați datele cu pipeline-ul TensorFlow

A doua metodă funcționează cel mai bine dacă aveți un set de date mare. De exemplu, dacă aveți un set de date de 50 de gigaocteți și computerul are doar 16 gigaocteți de memorie, atunci mașina se va bloca.

În această situație, trebuie să construiți o rețea TensorFlow. Rețeaua va încărca datele în loturi sau în bucăți mici. Fiecare lot va fi trimisă către rețea și va fi gata de antrenament. Construirea unei rețele este o soluție excelentă, deoarece vă permite să utilizați calculul paralel. Aceasta înseamnă că TensorFlow va antrena modelul pe mai multe procesoare. Acest lucru accelerează calculul și face practică antrenarea unor rețele mai mari.

Pe scurt: încărcați seturi de date mici în memorie cu ajutorul programelor Panda și utilizați o conductă TensorFlow atunci când datele sunt mari sau când doriți încărcare paralelă pe mai multe procesoare.

Cum se creează o conductă TensorFlow

Iată pașii pentru a crea o conductă TensorFlow:

În exemplul anterior, am adăugat manual trei valori pentru X_1 și X_2. Acum, vom vedea cum se încarcă datele în TensorFlow:

Pasul 1) Creați datele

În primul rând, să folosim biblioteca numpy pentru a genera două valori aleatorii.

import numpy as np
x_input = np.random.sample((1,2))
print(x_input)

[[0.8835775 0.23766977]]

Pasul 2) Creați substituent

Ca și în exemplul anterior, creăm un substituent cu numele X. Trebuie să specificăm în mod explicit forma tensorului. În cazul în care, vom încărca o matrice cu doar două valori. Putem scrie forma ca form=[1,2]

# using a placeholder
x = tf.placeholder(tf.float32, shape=[1,2], name = 'X')

Pasul 3) Definiți metoda setului de date

În continuare, trebuie să definim setul de date unde putem popula valoarea substituentului x. Trebuie să folosim metoda tf.data.Dataset.from_tensor_slices

dataset = tf.data.Dataset.from_tensor_slices(x)

Pasul 4) Creați conducta

La pasul patru, trebuie să inițializam conducta în care vor curge datele. Trebuie să creăm un iterator cu make_initializable_iterator. Îl numim iterator. Apoi trebuie să apelăm acest iterator pentru a alimenta următorul lot de date, get_next. Numim acest pas get_next. Rețineți că în exemplul nostru, există un singur lot de date cu doar două valori.

iterator = dataset.make_initializable_iterator() 
get_next = iterator.get_next()

Pasul 5) Executați operația

Ultimul pas este similar cu exemplul anterior. Initiem o sesiune si rulam iteratorul de operatie. Alimentam feed_dict cu valoarea generată de NumPy. Aceste două valori vor popula substituentul x. Apoi rulăm get_next pentru a imprima rezultatul.

with tf.Session() as sess:
    # feed the placeholder with data
    sess.run(iterator.initializer, feed_dict={ x: x_input }) 
    print(sess.run(get_next))

[0.8835775  0.23766978]

TensorFlow 1.x vs TensorFlow 2.x: Ce s-a schimbat

TensorFlow 2.0 a fost o rescriere revoluționară a API-ului orientat către utilizator. Înțelegerea diferenței este importantă, deoarece o mare parte din codul tutorialelor online, inclusiv exemplele de mai sus, vizează stilul 1.x.

Exemplul de înmulțire, rescris. Trei pași și o sesiune devin o singură linie, deoarece operația se execută în momentul în care este apelată:

import tensorflow as tf

X_1 = tf.constant([1, 2, 3], dtype=tf.float32)
X_2 = tf.constant([4, 5, 6], dtype=tf.float32)

result = tf.multiply(X_1, X_2, name="multiply")
print(result.numpy())        # [ 4. 10. 18.]

Conducta de intrare, rescrisă. Nu sunt necesari substituenți și niciun obiect iterator:

import numpy as np
import tensorflow as tf

x_input = np.random.sample((1, 2))
dataset = tf.data.Dataset.from_tensor_slices(x_input)

for batch in dataset:
    print(batch.numpy())

Dacă aveți nevoie de viteza unui grafic compilat, încadrați funcția în @tf.function și TensorFlow. tracîl transformă automat într-unul singur. Scripturile Legacy 1.x pot fi, de asemenea, rulate neschimbate prin intermediul spațiului de nume tf.compat.v1, deși acea cale este doar pentru întreținere și nu ar trebui utilizată pentru lucrări noi.

TensorFlow: Concluzii cheie și Code Referinţă

• Sensul TensorFlow: TensorFlow este cea mai faimoasă bibliotecă de deep learning din ultimii ani. Un practicant care utilizează TensorFlow poate construi orice structură de învățare profundă, cum ar fi CNN, RNN sau o simplă rețea neuronală artificială.
• TensorFlow este utilizat în principal de către cadrele universitare, startup-uri și companii mari. Google folosește TensorFlow în aproape toate Google produse zilnice, inclusiv Gmail, Fotografie și Google Motor de căutare.
• Google Echipa Brain a dezvoltat TensorFlow pentru a reduce decalajul dintre cercetători și dezvoltatorii de produse. În 2015, au lansat TensorFlow la scară publică; popularitatea sa crește rapid. În zilele noastre, TensorFlow este biblioteca de deep learning cu cele mai multe repozitorii pe GitHub.
• Practicienii folosesc TensorFlow deoarece se implementează cu ușurință la scară largă, în cloud, în browser sau pe dispozitive mobile care rulează iOS și Android.

TensorFlow funcționează într-o sesiune. Fiecare sesiune este definită de un grafic cu diferite calcule. Un exemplu simplu poate fi înmulțirea cu un număr. În TensorFlow, sunt necesari trei pași:

1. Definiți variabila

X_1 = tf.placeholder(tf.float32, name = "X_1")
X_2 = tf.placeholder(tf.float32, name = "X_2")

2. Definiți calculul

multiply = tf.multiply(X_1, X_2, name = "multiply")

3. Executați operația

with tf.Session() as session:
    result = session.run(multiply, feed_dict={X_1: [1, 2, 3], X_2: [4, 5, 6]})
    print(result)

O practică obișnuită în TensorFlow este crearea unui pipeline pentru încărcarea datelor. Dacă urmați acești cinci pași, veți putea încărca date în TensorFLow:

1. Creați datele

import numpy as np
x_input = np.random.sample((1,2))
print(x_input)

2. Creați substituentul

x = tf.placeholder(tf.float32, shape=[1,2], name = 'X')

3. Definiți metoda setului de date

dataset = tf.data.Dataset.from_tensor_slices(x)

4. Creați conducta

iterator = dataset.make_initializable_iterator()
get_next = iterator.get_next()

5. Executați programul

with tf.Session() as sess:
    sess.run(iterator.initializer, feed_dict={x: x_input})
    print(sess.run(get_next))

Întrebări frecvente