Che cos'è un tensore in TensorFlow? Forma, tipo e OperaTors

Cos'è un tensore?

Il nome TensorFlow deriva direttamente dal suo oggetto principale: il tensore. In TensorFlow, ogni calcolo coinvolge i tensori. Un tensore è un vettore o una matrice di n dimensioni che rappresenta tutti i tipi di dati. Tutti i valori in un tensore contengono un tipo di dati identico con una forma nota (o parzialmente nota), e la forma dei dati è la dimensionalità della matrice o dell'array.

Un tensore può derivare dai dati di input o dal risultato di un calcolo. In TensorFlow, tutte le operazioni vengono eseguite all'interno di un grafo. Il grafo è un insieme di calcoli che si susseguono. Ogni operazione è chiamata nodo operativo (op node) e i nodi sono collegati tra loro.

Il grafico illustra le operazioni e le connessioni tra i nodi. Tuttavia, non visualizza i valori. Il collegamento tra i nodi rappresenta il tensore, ovvero un modo per popolare l'operazione con i dati.

Nell'apprendimento automatico, i modelli vengono alimentati con un elenco di oggetti chiamati vettori di caratteristiche. Un vettore di caratteristiche può essere di qualsiasi tipo di dato ed è solitamente l'input principale che popola un tensore. Questi valori fluiscono in un nodo operativo attraverso il tensore e il risultato di tale operazione crea un nuovo tensore, che a sua volta viene utilizzato in una nuova operazione. Tutte queste operazioni possono essere visualizzate nel grafico.

Rappresentazione di un tensore

In TensorFlow, un tensore è una collezione di vettori di caratteristiche (ovvero un array) di n dimensioni. Ad esempio, se abbiamo una matrice 2×3 con valori da 1 a 6, la scriviamo come la matrice mostrata di seguito:

TensorFlow rappresenta questa matrice come:

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

Se creiamo una matrice tridimensionale con valori da 1 a 8, gli stessi dati vengono rappresentati come una scatola con due facce sovrapposte:

TensorFlow rappresenta questa matrice come:

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

Nota: un tensore può essere rappresentato con uno scalare oppure può avere una forma con più di tre dimensioni. È semplicemente più difficile visualizzare i livelli di dimensione superiori.

Tipi di tensore

In TensorFlow, tutti i calcoli passano attraverso uno o più tensori. Un tf.Tensor è un oggetto con tre proprietà:

• Un'etichetta univoca (nome)
• Una dimensione (forma)
• Un tipo di dati (dtype)

Ogni operazione che esegui con TensorFlow implica la manipolazione di un tensore. Esistono quattro tipi principali di tensori che puoi creare:

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

In questo tutorial imparerai come creare un tf.constant e tf.Variable.

Un punto da tenere a mente prima di eseguire il codice: questo tutorial segue l'API originale di TensorFlow 1.x, in cui un grafico viene prima costruito ed eseguito successivamente all'interno di una sessione. TensorFlow 2 viene eseguito in modalità eager per impostazione predefinita, quindi molti dei simboli seguenti sono stati spostati o rimossi. Ognuno di essi è comunque raggiungibile tramite il tf.compat.v1 namespace, e la tabella associa ciascuno alla sua controparte moderna.

Prima di iniziare il tutorial, assicurati di attivare l'ambiente conda in cui è installato TensorFlow. Questo ambiente si chiama hello-tf.

Per macOS gli utenti:

source activate hello-tf

Per Windows gli utenti:

activate hello-tf

Una volta completata questa operazione, sarete pronti per importare TensorFlow.

# Import tf
import tensorflow as tf

Crea un tensore di n-dimensione

Inizi con la creazione di un tensore con una dimensione, vale a dire uno scalare.

Per creare un tensore, puoi usare tf.constant() come mostrato nell'esempio di forma del tensore TensorFlow riportato di seguito:

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`

Per creare un tensore di dimensione 0, eseguire il seguente codice.

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

Uscita

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

Le tre parti di tale output corrispondono alle tre proprietà del tensore, come chiarisce la versione annotata qui sotto.

Puoi anche dare al tensore un nome tuo con il name discussione.

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

Uscita

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

Ciascun tensore viene visualizzato tramite il suo nome. Ogni oggetto tensore è definito da attributi quali un'etichetta univoca (nome), una dimensione (forma) e un tipo di dati TensorFlow (dtype).

È possibile definire un tensore con valori decimali o con una stringa modificando il tipo di dati.

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

Uscita

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

Un tensore di dimensione 1 può essere creato nel modo seguente:

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

Uscita

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

Come si può notare, la forma di TensorFlow è composta da una sola colonna.

Per creare un array di tensori con 2 dimensioni, è necessario chiudere le parentesi dopo ogni riga. Consulta l'esempio di forma del tensore qui sotto.

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

Uscita

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

La matrice ha 2 righe e 2 colonne riempite con i valori 1, 2, 3 e 4.

Si costruisce una matrice a 3 dimensioni aggiungendo un ulteriore livello di parentesi.

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

Uscita

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

Il risultato corrisponde al diagramma tridimensionale a scatola mostrato in precedenza in questo tutorial.

Forma del tensore

Quando stampi un tensore, TensorFlow deduce la forma. Tuttavia, puoi leggere la forma direttamente con TensorFlow shape proprietà.

Di seguito, costruisci una matrice riempita con i numeri da 10 a 15 e controlli la forma di m_shape.

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

Uscita

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

La matrice ha 3 righe e 2 colonne.

TensorFlow dispone di comandi utili per creare un vettore o una matrice riempita con 0 o 1. Ad esempio, se desideri creare un tensore 1-D con una forma specifica di 10, riempita con 0, puoi eseguire il codice seguente:

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

Uscita

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

La proprietà funziona anche per una matrice. Qui, si crea una matrice 10×10 riempita con 1.

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

Uscita

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

È possibile utilizzare la forma di una data matrice per creare un vettore di uno. La matrice m_shape ha dimensioni 3×2, quindi il seguente codice crea un tensore con 3 righe riempite di uno:

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

Uscita

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

Se passi il valore 1 tra parentesi, costruisci un vettore di uno pari al numero di colonne della matrice m_shape.

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

Uscita

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

Infine, è possibile creare una matrice 3×2 riempita interamente con numeri uno.

print(tf.ones(m_shape.shape))

Uscita

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

Tipo di dati

La seconda proprietà di un tensore è il tipo di dati. Un tensore può contenere un solo tipo di dati alla volta e puoi leggere quel tipo con il dtype proprietà.

print(m_shape.dtype)

Uscita

<dtype: &#x27;int32'>

In alcune occasioni, si desidera modificare il tipo di dati. In TensorFlow, ciò è possibile con il tf.cast metodo.

Esempio

Di seguito, un tensore float viene convertito in un intero con il cast metodo.

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

Uscita

<dtype: &#x27;float32'>
<dtype: &#x27;int32'>

TensorFlow sceglie automaticamente il tipo di dati quando l'argomento non viene specificato durante la creazione del tensore. TensorFlow ipotizza il tipo di dati più probabile: se, ad esempio, si passa del testo, deduce che si tratti di una stringa.

Creazione Operator

Alcuni utili TensorFlow OperaTors

Sai come creare un tensore con TensorFlow. È tempo di imparare come eseguire operazioni matematiche.

TensorFlow include tutte le operazioni di base. Puoi iniziare con una semplice e utilizzare un metodo di TensorFlow per calcolare la radice quadrata di un numero. Questa operazione è semplice perché richiede un solo argomento per costruire il tensore.

La radice quadrata di un numero è costruita con tf.sqrt(x), dove x è un numero in virgola mobile.

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

Uscita

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

Nota: l'output ha restituito un oggetto tensore e non la radice quadrata di 2. In questo esempio, viene stampata la definizione del tensore e non la valutazione effettiva dell'operazione. Nella sezione Sessione qui sotto, imparerai come TensorFlow esegue le operazioni.

Di seguito è riportato un elenco delle operazioni più comuni. Il concetto è sempre lo stesso: ogni operazione richiede uno o più argomenti.

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

Esempio

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

Uscita

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

Code Spiegazione

Crea due tensori:

• un tensore con 1 e 2
• un tensore con 3 e 4

Sommi entrambi i tensori.

Si noti che entrambi i tensori devono avere la stessa forma. È anche possibile eseguire una moltiplicazione tra i due tensori.

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

Uscita

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

Variabili

Finora hai creato solo tensori costanti, che di per sé hanno un'utilità limitata. I dati arrivano sempre con valori diversi e per rappresentarli puoi usare la classe Variable. Una variabile rappresenta un nodo i cui valori cambiano nel tempo.

Per creare una variabile, puoi usare tf.get_variable() metodo.

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.

Ad esempio, il codice seguente crea una variabile bidimensionale con due valori casuali. Per impostazione predefinita, TensorFlow restituisce un valore casuale. Si assegna alla variabile il nome var.

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

Uscita

(1, 2)

In questo esempio, si crea una variabile con una riga e due colonne, quindi si passa [1, 2] come dimensione della variabile.

I valori iniziali di un tensore possono anche essere zero. Quando si addestra un modello, ad esempio, sono necessari valori iniziali prima di calcolare il peso delle caratteristiche. Di seguito, si impostano questi valori iniziali a zero.

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

Uscita

(1, 2)

È anche possibile passare i valori di un tensore costante a una variabile. Si crea un tensore costante con il metodo tf.constant() e utilizzare quel tensore per inizializzare la variabile.

I primi valori della variabile sono 10, 20, 30 e 40. Il nuovo tensore ha una 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)

Uscita

(2, 2)

segnaposto

Un placeholder ha lo scopo di alimentare il tensore. Un placeholder inizializza i dati che fluiranno all'interno dei tensori. Per fornire un placeholder, si utilizza il feed_dict argomento, e il segnaposto viene alimentato solo all'interno di una sessione.

Nel prossimo esempio, vedrai come creare un segnaposto con il metodo tf.placeholderNella sezione Sessione, imparerai ad alimentare un segnaposto con un valore tensoriale effettivo.

La sintassi è:

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)

Uscita

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

Sessione

TensorFlow funziona attorno a 3 componenti principali:

• Grafico
• tensore
• Sessione

Grafici e sessioni sono indipendenti. È possibile eseguire una sessione e conservare i valori per ulteriori calcoli in seguito.

Nell'esempio seguente, dovrai:

• Crea due tensori
• Creare un'operazione
• Apri una sessione
• Stampa il risultato

Passaggio 1) Si creano due tensori x e y

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

Passaggio 2) Si crea l'operatore moltiplicando x e y

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

Passaggio 3) Apri una sessione. Tutti i calcoli avvengono all'interno della sessione e, al termine, devi chiuderla.

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

Uscita

[8]

Code spiegazione

• tf.Session(): Apri una sessione. Tutte le operazioni si svolgono all'interno della sessione
• run(multiply): eseguire l'operazione creata nel passaggio 2
• print(result_1)Infine, puoi stampare il risultato
• close(): Chiudi la sessione

Il risultato mostra 8, che è la moltiplicazione di xey.

Un altro modo per creare una sessione è all'interno di un blocco. Il vantaggio è che la sessione viene chiusa automaticamente.

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

Uscita

[8]

Nel contesto di una sessione, è possibile utilizzare il eval() metodo per eseguire l'operazione. È equivalente a run() e rende il codice più leggibile.

Puoi creare una sessione e vedere i valori all'interno dei tensori che hai creato finora.

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

Uscita

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

Le variabili sono vuote per impostazione predefinita, anche dopo aver creato il tensore. È necessario inizializzare una variabile prima di poterla utilizzare. L'oggetto tf.global_variables_initializer() viene chiamata per inizializzare i valori di tutte le variabili contemporaneamente, il che è utile prima di addestrare un modello.

È possibile verificare i valori delle variabili create in precedenza. Si noti che è necessario utilizzare il comando `run` per valutare il tensore.

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

Uscita

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

Puoi usare il segnaposto creato in precedenza e alimentarlo con un valore effettivo. Devi passare i dati nel feed_dict discussione.

Ad esempio, prenderai la potenza di 2 del segnaposto 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 Spiegazione

• import numpy as np: Importa il file NumPy libreria per creare i dati
• tf.pow(data_placeholder_a, 2): Creare le operazioni
• np.random.rand(1, 10): Crea un array di dati casuale
• feed_dict={data_placeholder_a: data}: Inserisci i dati nel segnaposto

Uscita

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

Grafico

TensorFlow rappresenta ogni operazione con uno schema di flusso di dati. Il grafico del flusso di dati è stato progettato per mostrare le dipendenze tra le singole operazioni. Una formula matematica o un algoritmo è composto da una serie di operazioni successive e un grafico è un modo pratico per visualizzare come questi calcoli sono coordinati.

Il grafico mostra nodi e archi. Un nodo rappresenta un'operazione, ovvero l'unità di calcolo. Un arco rappresenta il tensore: può produrre un nuovo tensore o consumare i dati di input, a seconda delle dipendenze tra le singole operazioni.

La struttura del grafico collega le operazioni (ovvero i nodi) e mostra come ciascuna di esse viene alimentata. Si noti che il grafico non visualizza l'output delle operazioni; serve solo a visualizzare le connessioni tra di esse.

Vediamo un esempio. Immaginiamo di voler valutare la seguente funzione:

TensorFlow crea un grafo per eseguire la funzione. Il grafo ha questo aspetto:

Puoi facilmente vedere il percorso che i tensori seguiranno per raggiungere la destinazione finale.

Per esempio, la add il nodo non può essere eseguito prima di entrambi Mul and Pow hanno prodotto i loro risultati. Il grafico mostra che TensorFlow:

1. calcolare x·z nel Mul nodo e x² nel Pow nodo
2. sommare questi due risultati nel add nodo
3. aggiungi z a quella somma nel add_1 nodo
4. aggiungere la costante 5 nel add_2 nodo

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 Spiegazione

• x: inizializza una variabile chiamata x con un valore costante pari a 5
• z: inizializza una variabile chiamata z con un valore costante pari a 6
• c: inizializza un tensore costante chiamato c con un valore costante pari a 5
• quadrato: inizializza un tensore costante chiamato quadrato con un valore costante pari a 2
• f: Costruisci l'operatore

In questo esempio, i valori delle variabili sono mantenuti fissi. Il tensore costante c è il parametro costante nella funzione f e assume un valore fisso di 5; nel grafico è possibile vedere questo parametro nel tensore chiamato costante.

È stato inoltre creato un tensore costante per la potenza nell'operatore tf.pow()Non è necessario, ma significa che l'esponente appare nel grafico come il cerchio chiamato quadrato.

Dal grafico si può seguire l'evoluzione dei tensori e capire perché la funzione restituisce 66: 5 × 6 più 5² più 6 più 5 è uguale a 66.

Il codice seguente valuta la funzione all'interno di una sessione.

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)

Uscita

[66]

Nozioni di base di TensorFlow - Guida rapida

Le quattro tabelle seguenti raccolgono tutti i comandi utilizzati in questo tutorial, in modo da poterli consultare senza dover scorrere indietro tra gli esempi.

Crea un tensore costante

Creare un operatore

Creare un tensore variabile

Apri una sessione

DOMANDE FREQUENTI