Cos'è TensorFlow? Come funziona? Archistruttura e caratteristiche

Cos'è TensorFlow?

TensorFlow è una piattaforma end-to-end open source per la creazione di applicazioni di machine learning. Si tratta di una libreria matematica simbolica che utilizza il flusso di dati e la programmazione differenziabile per eseguire vari compiti incentrati sull'addestramento e sull'inferenza delle reti neurali profonde. Consente agli sviluppatori di creare applicazioni di machine learning utilizzando vari strumenti, librerie e risorse della community.

Attualmente, la libreria di deep learning più famosa al mondo è GoogleTensorFlow. Google Applica l'apprendimento automatico a tutti i suoi prodotti per migliorare la ricerca, la traduzione, la generazione di didascalie per le immagini e i sistemi di raccomandazione.

Esempio di TensorFlow

Per fare un esempio concreto, Google Gli utenti possono sperimentare un'esperienza di ricerca più rapida e raffinata grazie all'IA. Se l'utente digita una parola chiave nella barra di ricerca, Google fornisce un suggerimento su quale potrebbe essere la parola successiva.

Google vuole utilizzare l'apprendimento automatico per sfruttare i suoi enormi set di dati e offrire agli utenti la migliore esperienza possibile. Tre diversi gruppi utilizzano l'apprendimento automatico:

• Ricercatori
• Scienziati dei dati
• I programmatori

Tutti possono utilizzare lo stesso set di strumenti per collaborare tra loro e migliorare la propria efficienza.

Google non solo contiene grandi set di dati, ma esegue anche un'enorme infrastruttura di calcolo, quindi TensorFlow è stato costruito per scalare fin dall'inizio. TensorFlow è una libreria sviluppata da Google Brain Team accelererà la ricerca sull'apprendimento automatico e sulle reti neurali profonde.

È stato creato per funzionare su più CPU o GPU e persino su sistemi operativi mobili, e ha diversi wrapper in diversi linguaggi come Python, C++ or Java.

Storia di TensorFlow

Un paio di anni fa, il deep learning ha iniziato a superare tutti gli altri algoritmi di machine learning quando si trattava di grandi quantità di dati. Google ha capito che poteva utilizzare queste reti neurali profonde per migliorare i suoi servizi:

• Gmail
• Foto
• Google motore di ricerca

Hanno costruito un framework chiamato TensorFlow in modo che ricercatori e sviluppatori potessero lavorare sullo stesso modello, per poi implementarlo su una scala utilizzabile da molte persone.

TensorFlow è stato rilasciato pubblicamente nel novembre 2015 e la versione 1.0 è seguita nel febbraio 2017. Il cambiamento più grande è arrivato con TensorFlow 2.0 a settembre 2019, che ha reso l'esecuzione eager l'impostazione predefinita e ha adottato Keras come API di alto livello standard. Dalla versione 2.16 in poi, Keras 3 è l'impostazione predefinita e lo stesso codice modello può essere eseguito anche su JAX o PyTorbackend ch.

TensorFlow è rilasciato sotto licenza Apache 2.0, quindi è possibile utilizzarlo, modificarlo e ridistribuirlo, anche a fini commerciali, senza pagare Google.

Come funziona TensorFlow

TensorFlow ti consente di creare grafici e strutture del flusso di dati per definire il modo in cui i dati si muovono attraverso un grafico prendendo gli input come un array multidimensionale chiamato Tensor. Ti consente di costruire un diagramma di flusso delle operazioni che possono essere eseguite su questi input, che va da un lato e arriva all'altra estremità come output.

TensorFlow Architectura

L'architettura di TensorFlow si articola in tre parti:

• Preelaborazione dei dati
• Costruisci il modello
• Addestrare e stimare il modello

Si chiama TensorFlow perché prende input come un array multidimensionale, noto anche come tensori. Puoi costruire una sorta di diagramma di flusso di operazioni (chiamate Grafico) che si desidera eseguire su quell'input. L'input entra da un'estremità, quindi scorre attraverso questo sistema di operazioni multiple ed esce dall'altra estremità come output.

Dove può essere eseguito TensorFlow?

I requisiti hardware e software di TensorFlow si suddividono in due fasi:

Fase di sviluppo: questa è la fase in cui si addestra il modello, solitamente su un computer fisso o portatile.

Fase di esecuzione o di inferenzaUna volta completato l'addestramento, il modello può essere eseguito su diverse piattaforme:

• Desktop in esecuzione Windows, macOS o Linux
• Il cloud come servizio web
• Dispositivi mobili come iOS e Android

Puoi addestrarlo su più macchine, quindi puoi eseguirlo su una macchina diversa, una volta ottenuto il modello addestrato.

Il modello può essere addestrato e utilizzato sia su GPU che su CPU. Le GPU sono state inizialmente progettate per i videogiochi. Intorno al 2009, i ricercatori di Stanford hanno dimostrato che le GPU sono estremamente efficienti nelle operazioni di algebra lineare e matriciale da cui dipendono le reti neurali. Il deep learning si basa su molte moltiplicazioni di matrici. TensorFlow è molto veloce nel calcolare la moltiplicazione di matrici perché è scritto in C++. Sebbene sia implementato in C++, TensorFlow è accessibile e controllabile principalmente da altri linguaggi, Python.

Un'altra caratteristica significativa è Scheda Tensorche visualizza il grafico, le metriche di addestramento e la distribuzione dei pesi durante l'esecuzione del modello.

Componenti di TensorFlow

tensore

Il nome di TensorFlow deriva direttamente dal suo framework principale: tensoreIn TensorFlow, tutti i calcoli coinvolgono tensori. Un tensore è un vettore or matrice di n-dimensioni che rappresentano tutti i tipi di dati. Tutti i valori in un tensore contengono un tipo di dati identico con un valore noto (o parzialmente noto) shape. La forma dei dati è la dimensionalità della matrice o dell'array.

Un tensore può essere originato dai dati di input o dal risultato di un calcolo. In TensorFlow, tutte le operazioni vengono condotte all'interno di a grafico. Il grafico è un insieme di calcoli che avvengono successivamente. Ogni operazione è chiamata an nodo op e sono collegati tra loro.

Il grafico delinea le operazioni e le connessioni tra i nodi. Tuttavia, non visualizza i valori. Il bordo dei nodi è il tensore, cioè un modo per popolare l'operazione con i dati.

Grafici

TensorFlow utilizza una struttura grafica. Il grafico raccoglie e descrive tutte le serie di calcoli effettuate durante l'addestramento. Il grafico ha molti vantaggi:

• Funziona su più CPU o GPU e persino su sistemi operativi mobili.
• La portabilità del grafico consente di conservare i calcoli per un uso immediato o successivo. Il grafico può essere salvato per essere eseguito in futuro.
• Tutti i calcoli nel grafico vengono eseguiti collegando insieme i tensori
  • Un grafo è costituito da nodi e archi. Ogni nodo rappresenta un'operazione matematica e produce un output, mentre gli archi descrivono le relazioni di input e output tra i nodi. I tensori stessi si muovono lungo gli archi.

Perché TensorFlow è popolare?

TensorFlow è ampiamente diffuso perché accessibile a ogni livello di competenza. Le sue API coprono tutto, da un modello Keras di tre righe a una CNN o RNN costruita manualmente. Poiché il calcolo è espresso come un grafo, TensorBoard può visualizzare la rete e semplificare notevolmente il debug. Inoltre, è scalabile e può essere eseguito su CPU, GPU e TPU, nonché su dispositivi mobili tramite TensorFlow Lite.

TensorFlow rimane uno dei due framework di deep learning più utilizzati su GitHub, insieme a PyTorch.

TensorFlow Algorithms

TensorFlow include stimatori di alto livello per diversi algoritmi classici. In TensorFlow 1.x questi erano gestiti tramite tf.estimator:

• Regressione lineare: tf.estimator.LinearRegressor
• Classificazione: tf.estimator.LinearClassifier
• Classificazione dell'apprendimento profondo: tf.estimator.DNNClassifier
• Apprendimento ampio e approfondito: tf.estimator.DNNLinearCombinedClassifier
• Regressione ad albero potenziata: tf.estimator.BoostedTreesRegressor
• Classificazione degli alberi potenziata: tf.estimator.BoostedTreesClassifier

TensorFlow vs PyTorch: Quale dovresti scegliere?

TensorFlow e PyTorch sono i due framework di deep learning dominanti e le differenze pratiche si sono ridotte considerevolmente da quando TensorFlow 2.0 ha adottato l'esecuzione eager.

La risposta pragmatica: scegli TensorFlow quando il modello deve essere distribuito su dispositivi mobili, browser o uno stack di server gestito e scegli PyTorquando si itera sull'architettura del modello. Keras 3, il predefinito da TensorFlow 2.16 in poi, attenua ulteriormente la decisione, perché lo stesso codice Keras può essere eseguito su un TensorFlow, JAX o PyTorbackend ch.

Come funzionano i calcoli in TensorFlow

import numpy as np
import tensorflow as tf

Nelle prime due righe di codice abbiamo importato tensorflow come tf. Con Python, è pratica comune utilizzare un nome breve per una libreria. Il vantaggio è quello di evitare di digitare il nome completo della libreria quando dobbiamo utilizzarla. Ad esempio, possiamo importare tensorflow come tf e chiamare tf quando vogliamo utilizzare una funzione tensorflow

Esercitiamoci con il flusso di lavoro elementare di TensorFlow attraverso semplici esempi. Creiamo un grafo computazionale che moltiplica due numeri.

Nell'esempio, moltiplicheremo X_1 e X_2. TensorFlow creerà un nodo per collegare l'operazione. Nel nostro esempio, si chiama "moltiplica". Una volta determinato il grafo, i motori di calcolo di TensorFlow moltiplicheranno X_1 e X_2.

Infine, eseguiremo una sessione TensorFlow che eseguirà il grafico computazionale con i valori di X_1 e X_2 e stamperà il risultato della moltiplicazione.

Definiamo i nodi di input X_1 e X_2. Quando creiamo un nodo in TensorFlow, dobbiamo scegliere il tipo di nodo da creare. I nodi X1 e X2 saranno nodi segnaposto. Il segnaposto assegna un nuovo valore ogni volta che eseguiamo un calcolo. Li creeremo come nodi segnaposto TF.dot.

Passaggio 1: definire la variabile

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

Un segnaposto necessita di un tipo di dati. In questo caso si tratta di numeri, quindi tf.float32 è la scelta corretta. L'argomento name è facoltativo ma utile, perché rappresenta l'etichetta che appare nella visualizzazione del grafico in TensorBoard. X_2 viene definito allo stesso modo.

Passaggio 2: definire il calcolo

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

Ora possiamo definire il nodo che esegue l'operazione di moltiplicazione. In TensorFlow possiamo farlo creando un nodo tf.multiply.

Passeremo i nodi X_1 e X_2 al nodo della moltiplicazione. Dice a tensorflow di collegare quei nodi nel grafico computazionale, quindi gli chiediamo di estrarre i valori da xey e moltiplicare il risultato. Diamo anche al nodo della moltiplicazione il nome moltiplicazione. È l'intera definizione del nostro semplice grafico computazionale.

Passaggio 3: eseguire l'operazione

Per eseguire operazioni sul grafo, dobbiamo creare una sessione. In TensorFlow, questo viene fatto tramite `tf.Session()`. Ora che abbiamo una sessione, possiamo chiedere alla sessione di eseguire operazioni sul nostro grafo computazionale chiamando `session`. Per eseguire il calcolo, dobbiamo usare `run`.

Quando viene eseguita l'operazione di moltiplicazione, sono necessari i valori dei nodi X_1 e X_2, quindi questi vengono forniti in fase di esecuzione. Possiamo farlo tramite un parametro chiamato feed_dict. Passiamo i valori 1, 2, 3 per X_1 e 4, 5, 6 per X_2.

Stampiamo i risultati con print(risultato). Dovremmo vedere 4, 10 e 18 per 1×4, 2×5 e 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.]

Opzioni per caricare i dati in TensorFlow

Il primo passo prima dell'allenamento a algoritmo di apprendimento automatico Si tratta di caricare i dati. Esistono due modi comuni per caricare i dati:

1. Caricare i dati in memoria: È il metodo più semplice. Carichi tutti i tuoi dati in memoria come un singolo array. Scrivi in ​​chiaro Python per questo; niente di tutto ciò è specifico di TensorFlow.

2. Pipeline di dati TensorFlowTensorFlow fornisce un'API integrata che carica i dati, applica le trasformazioni e li fornisce al modello. Questo metodo funziona molto bene, soprattutto quando si ha a che fare con un dataset di grandi dimensioni. Ad esempio, è risaputo che i file immagine sono enormi e non rientrano nella memoria disponibile. La pipeline di dati gestisce la memoria in modo autonomo.

Quale soluzione utilizzare?

Caricare i dati in memoria

Se il tuo set di dati non è troppo grande, ovvero meno di 10 gigabyte, puoi utilizzare il primo metodo. I dati possono entrare nella memoria. Puoi utilizzare una famosa libreria chiamata Pandas per importare file CSV. Imparerai di più sui panda nel prossimo tutorial.

Carica i dati con la pipeline di TensorFlow

Il secondo metodo funziona meglio se si dispone di un set di dati di grandi dimensioni. Ad esempio, se hai un set di dati di 50 gigabyte e il tuo computer ha solo 16 gigabyte di memoria, la macchina si bloccherà.

In questa situazione, è necessario creare una pipeline TensorFlow. La pipeline caricherà i dati in batch, ovvero in piccoli blocchi. Ogni batch verrà inviato alla pipeline e sarà pronto per l'addestramento. La creazione di una pipeline è un'ottima soluzione perché consente di utilizzare il calcolo parallelo. Ciò significa che TensorFlow addestrerà il modello su più CPU. Questo accelera i calcoli e rende pratico l'addestramento di reti neurali di grandi dimensioni.

In sintesi: carica piccoli set di dati in memoria con pandas e usa una pipeline TensorFlow quando i dati sono grandi o quando desideri un caricamento parallelo su più CPU.

Come creare una pipeline TensorFlow

Ecco i passaggi per creare una pipeline TensorFlow:

Nell'esempio precedente, abbiamo aggiunto manualmente tre valori per X_1 e X_2. Ora vedremo come caricare i dati in TensorFlow:

Passaggio 1) Creare i dati

Prima di tutto, utilizziamo la libreria Numpy per generare due valori casuali.

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

[[0.8835775 0.23766977]]

Passaggio 2) Crea il segnaposto

Come nell'esempio precedente, creiamo un segnaposto con il nome X. Dobbiamo specificare esplicitamente la forma del tensore. Nel caso, caricheremo un array con solo due valori. Possiamo scrivere la forma come shape=[1,2]

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

Passaggio 3) Definire il metodo del set di dati

Successivamente, dobbiamo definire il Dataset in cui possiamo popolare il valore del segnaposto x. Dobbiamo utilizzare il metodo tf.data.Dataset.from_tensor_slices

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

Passaggio 4) Creare la pipeline

Nel passaggio quattro, dobbiamo inizializzare la pipeline in cui fluiranno i dati. Dobbiamo creare un iteratore con make_initializable_iterator. Lo chiameremo iteratore. Quindi dobbiamo chiamare questo iteratore per alimentare il successivo batch di dati, get_next. Chiameremo questo passaggio get_next. Tieni presente che nel nostro esempio è presente un solo batch di dati con solo due valori.

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

Passaggio 5) Eseguire l'operazione

L'ultimo passaggio è simile all'esempio precedente. Avviamo una sessione ed eseguiamo l'iteratore dell'operazione. Alimentiamo feed_dict con il valore generato da numpy. Questi due valori popoleranno il segnaposto x. Quindi eseguiamo get_next per stampare il risultato.

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: cosa è cambiato?

TensorFlow 2.0 ha rappresentato una riscrittura radicale dell'API rivolta all'utente. Comprendere la differenza è importante, perché una grande quantità di codice tutorial online, inclusi gli esempi sopra riportati, si basa sullo stile della versione 1.x.

L'esempio della moltiplicazione, riscritto. Tre passaggi e una sessione diventano una sola riga, perché l'operazione viene eseguita nel momento stesso in cui viene richiamata:

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

La pipeline di input, riscritta. Non sono necessari né segnaposto né oggetto iteratore:

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

Se hai bisogno della velocità di un grafico compilato, racchiudi la funzione in @tf.function e TensorFlow traclo converte automaticamente in uno. Gli script legacy 1.x possono anche essere eseguiti senza modifiche tramite lo spazio dei nomi tf.compat.v1, sebbene tale percorso sia destinato esclusivamente alla manutenzione e non debba essere utilizzato per nuovi progetti.

TensorFlow: Punti chiave e Code Referenze

• Significato di TensorFlow: TensorFlow è la libreria di deep learning più famosa degli ultimi anni. Un professionista che utilizza TensorFlow può costruire qualsiasi struttura di deep learning, come CNN, RNN o una semplice rete neurale artificiale.
• TensorFlow è utilizzato principalmente da accademici, startup e grandi aziende. Google utilizza TensorFlow in quasi tutti i casi Google prodotti di uso quotidiano tra cui Gmail, Foto e Google Motore di ricerca.
• Migliori Google Il team di Brain ha sviluppato TensorFlow per colmare il divario tra ricercatori e sviluppatori di prodotti. Nel 2015, TensorFlow è stato reso pubblico e sta rapidamente guadagnando popolarità. Oggi, TensorFlow è la libreria di deep learning con il maggior numero di repository su GitHub.
• I professionisti utilizzano TensorFlow perché si distribuisce facilmente su larga scala, nel cloud, nel browser o su dispositivi mobili con sistema operativo iOS e Android.

TensorFlow funziona in sessioni. Ogni sessione è definita da un grafo con calcoli diversi. Un semplice esempio può essere la moltiplicazione di un numero. In TensorFlow, sono necessari tre passaggi:

1. Definisci la variabile

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

2. Definire il calcolo

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

3. Eseguire l'operazione

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

Una pratica comune in TensorFlow è quella di creare una pipeline per caricare i dati. Seguendo questi cinque passaggi, sarai in grado di caricare i dati in TensorFlow:

1. Creare i dati

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

2. Crea il segnaposto

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

3. Definire il metodo del set di dati

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

4. Crea la pipeline

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

5. Esegui il programma

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

DOMANDE FREQUENTI