 Visualizza su TensorFlow.org |  Esegui in Google Colab |  Visualizza l'origine su GitHub |  Scarica quaderno |
Per eseguire l'apprendimento automatico in TensorFlow, è probabile che tu debba definire, salvare e ripristinare un modello.
Un modello è, astrattamente:
- Una funzione che calcola qualcosa sui tensori (un passaggio in avanti )
- Alcune variabili che possono essere aggiornate in risposta alla formazione
In questa guida, andrai sotto la superficie di Keras per vedere come vengono definiti i modelli TensorFlow. Questo esamina come TensorFlow raccoglie variabili e modelli, nonché come vengono salvati e ripristinati.
Impostare
import tensorflow as tf
from datetime import datetime
%load_ext tensorboard
Definizione di modelli e livelli in TensorFlow
La maggior parte dei modelli è composta da strati. I livelli sono funzioni con una struttura matematica nota che possono essere riutilizzate e hanno variabili addestrabili. In TensorFlow, la maggior parte delle implementazioni di alto livello di livelli e modelli, come Keras o Sonnet , sono basate sulla stessa classe fondamentale: tf.Module .
Ecco un esempio di un tf.Module molto semplice che opera su un tensore scalare:
class SimpleModule(tf.Module):
def __init__(self, name=None):
super().__init__(name=name)
self.a_variable = tf.Variable(5.0, name="train_me")
self.non_trainable_variable = tf.Variable(5.0, trainable=False, name="do_not_train_me")
def __call__(self, x):
return self.a_variable * x + self.non_trainable_variable
simple_module = SimpleModule(name="simple")
simple_module(tf.constant(5.0))
<tf.Tensor: shape=(), dtype=float32, numpy=30.0>
I moduli e, per estensione, i livelli sono una terminologia di deep learning per "oggetti": hanno uno stato interno e metodi che utilizzano quello stato.
Non c'è niente di speciale in __call__ tranne che per agire come un richiamabile Python ; puoi invocare i tuoi modelli con qualsiasi funzione desideri.
È possibile attivare e disattivare l'addestrabilità delle variabili per qualsiasi motivo, incluso il congelamento dei livelli e delle variabili durante la messa a punto.
Sottoclasse tf.Module , tutte le istanze tf.Variable o tf.Module assegnate alle proprietà di questo oggetto vengono raccolte automaticamente. Ciò consente di salvare e caricare variabili e anche di creare raccolte di tf.Module s.
# All trainable variables
print("trainable variables:", simple_module.trainable_variables)
# Every variable
print("all variables:", simple_module.variables)
trainable variables: (<tf.Variable 'train_me:0' shape=() dtype=float32, numpy=5.0>,) all variables: (<tf.Variable 'train_me:0' shape=() dtype=float32, numpy=5.0>, <tf.Variable 'do_not_train_me:0' shape=() dtype=float32, numpy=5.0>) 2021-10-26 01:29:45.284549: W tensorflow/python/util/util.cc:348] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.
Questo è un esempio di un modello di livello lineare a due strati composto da moduli.
Prima uno strato denso (lineare):
class Dense(tf.Module):
def __init__(self, in_features, out_features, name=None):
super().__init__(name=name)
self.w = tf.Variable(
tf.random.normal([in_features, out_features]), name='w')
self.b = tf.Variable(tf.zeros([out_features]), name='b')
def __call__(self, x):
y = tf.matmul(x, self.w) + self.b
return tf.nn.relu(y)
E poi il modello completo, che crea due istanze di livello e le applica:
class SequentialModule(tf.Module):
def __init__(self, name=None):
super().__init__(name=name)
self.dense_1 = Dense(in_features=3, out_features=3)
self.dense_2 = Dense(in_features=3, out_features=2)
def __call__(self, x):
x = self.dense_1(x)
return self.dense_2(x)
# You have made a model!
my_model = SequentialModule(name="the_model")
# Call it, with random results
print("Model results:", my_model(tf.constant([[2.0, 2.0, 2.0]])))
Model results: tf.Tensor([[7.706234 3.0919805]], shape=(1, 2), dtype=float32)
Le istanze tf.Module raccoglieranno automaticamente, in modo ricorsivo, tutte le istanze tf.Variable o tf.Module ad esse assegnate. Ciò consente di gestire raccolte di tf.Module con una singola istanza di modello e di salvare e caricare interi modelli.
print("Submodules:", my_model.submodules)
Submodules: (<__main__.Dense object at 0x7f7ab2391290>, <__main__.Dense object at 0x7f7b6869ea10>)
for var in my_model.variables:
print(var, "\n")
<tf.Variable 'b:0' shape=(3,) dtype=float32, numpy=array([0., 0., 0.], dtype=float32)>
<tf.Variable 'w:0' shape=(3, 3) dtype=float32, numpy=
array([[ 0.05711935, 0.22440144, 0.6370985 ],
[ 0.3136791 , -1.7006774 , 0.7256515 ],
[ 0.16120772, -0.8412193 , 0.5250952 ]], dtype=float32)>
<tf.Variable 'b:0' shape=(2,) dtype=float32, numpy=array([0., 0.], dtype=float32)>
<tf.Variable 'w:0' shape=(3, 2) dtype=float32, numpy=
array([[-0.5353216 , 1.2815404 ],
[ 0.62764466, 0.47087234],
[ 2.19187 , 0.45777202]], dtype=float32)>
In attesa di creare variabili
Potresti aver notato qui che devi definire le dimensioni di input e output per il livello. In questo modo la variabile w ha una forma nota e può essere allocata.
Rinviando la creazione della variabile alla prima volta che il modulo viene chiamato con una forma di input specifica, non è necessario specificare la dimensione dell'input in anticipo.
class FlexibleDenseModule(tf.Module):
# Note: No need for `in_features`
def __init__(self, out_features, name=None):
super().__init__(name=name)
self.is_built = False
self.out_features = out_features
def __call__(self, x):
# Create variables on first call.
if not self.is_built:
self.w = tf.Variable(
tf.random.normal([x.shape[-1], self.out_features]), name='w')
self.b = tf.Variable(tf.zeros([self.out_features]), name='b')
self.is_built = True
y = tf.matmul(x, self.w) + self.b
return tf.nn.relu(y)
# Used in a module
class MySequentialModule(tf.Module):
def __init__(self, name=None):
super().__init__(name=name)
self.dense_1 = FlexibleDenseModule(out_features=3)
self.dense_2 = FlexibleDenseModule(out_features=2)
def __call__(self, x):
x = self.dense_1(x)
return self.dense_2(x)
my_model = MySequentialModule(name="the_model")
print("Model results:", my_model(tf.constant([[2.0, 2.0, 2.0]])))
Model results: tf.Tensor([[4.0598335 0. ]], shape=(1, 2), dtype=float32)
Questa flessibilità è il motivo per cui i livelli di TensorFlow spesso devono solo specificare la forma dei loro output, ad esempio in tf.keras.layers.Dense , piuttosto che la dimensione sia dell'input che dell'output.
Risparmio di pesi
Puoi salvare un tf.Module sia come checkpoint che come SavedModel .
I checkpoint sono solo i pesi (ovvero i valori dell'insieme di variabili all'interno del modulo e dei suoi sottomoduli):
chkp_path = "my_checkpoint"
checkpoint = tf.train.Checkpoint(model=my_model)
checkpoint.write(chkp_path)
'my_checkpoint'
I checkpoint sono costituiti da due tipi di file: i dati stessi e un file di indice per i metadati. Il file di indice tiene traccia di ciò che viene effettivamente salvato e la numerazione dei checkpoint, mentre i dati del checkpoint contengono i valori delle variabili e i relativi percorsi di ricerca degli attributi.
ls my_checkpoint*
my_checkpoint.data-00000-of-00001 my_checkpoint.index
Puoi guardare all'interno di un checkpoint per assicurarti che l'intera raccolta di variabili sia salvata, ordinata in base all'oggetto Python che le contiene.
tf.train.list_variables(chkp_path)
[('_CHECKPOINTABLE_OBJECT_GRAPH', []),
('model/dense_1/b/.ATTRIBUTES/VARIABLE_VALUE', [3]),
('model/dense_1/w/.ATTRIBUTES/VARIABLE_VALUE', [3, 3]),
('model/dense_2/b/.ATTRIBUTES/VARIABLE_VALUE', [2]),
('model/dense_2/w/.ATTRIBUTES/VARIABLE_VALUE', [3, 2])]
Durante l'addestramento distribuito (multi-macchina) possono essere partizionati, motivo per cui sono numerati (ad esempio, '00000-of-00001'). In questo caso, però, c'è solo uno shard.
Quando carichi nuovamente i modelli, sovrascrivi i valori nel tuo oggetto Python.
new_model = MySequentialModule()
new_checkpoint = tf.train.Checkpoint(model=new_model)
new_checkpoint.restore("my_checkpoint")
# Should be the same result as above
new_model(tf.constant([[2.0, 2.0, 2.0]]))
<tf.Tensor: shape=(1, 2), dtype=float32, numpy=array([[4.0598335, 0. ]], dtype=float32)>
Funzioni di salvataggio
TensorFlow può eseguire modelli senza gli oggetti Python originali, come dimostrato da TensorFlow Serving e TensorFlow Lite , anche quando scarichi un modello addestrato da TensorFlow Hub .
TensorFlow deve sapere come eseguire i calcoli descritti in Python, ma senza il codice originale . Per fare ciò, puoi creare un grafico , che è descritto nella Guida introduttiva ai grafici e alle funzioni .
Questo grafico contiene operazioni, o ops , che implementano la funzione.
Puoi definire un grafico nel modello sopra aggiungendo il decoratore @tf.function per indicare che questo codice deve essere eseguito come grafico.
class MySequentialModule(tf.Module):
def __init__(self, name=None):
super().__init__(name=name)
self.dense_1 = Dense(in_features=3, out_features=3)
self.dense_2 = Dense(in_features=3, out_features=2)
@tf.function
def __call__(self, x):
x = self.dense_1(x)
return self.dense_2(x)
# You have made a model with a graph!
my_model = MySequentialModule(name="the_model")
Il modulo che hai creato funziona esattamente come prima. Ogni firma univoca passata alla funzione crea un grafico separato. Per i dettagli, consultare la Guida introduttiva ai grafici e alle funzioni .
print(my_model([[2.0, 2.0, 2.0]]))
print(my_model([[[2.0, 2.0, 2.0], [2.0, 2.0, 2.0]]]))
tf.Tensor([[0.62891716 0. ]], shape=(1, 2), dtype=float32) tf.Tensor( [[[0.62891716 0. ] [0.62891716 0. ]]], shape=(1, 2, 2), dtype=float32)
Puoi visualizzare il grafico tracciandolo all'interno di un riepilogo TensorBoard.
# Set up logging.
stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
logdir = "logs/func/%s" % stamp
writer = tf.summary.create_file_writer(logdir)
# Create a new model to get a fresh trace
# Otherwise the summary will not see the graph.
new_model = MySequentialModule()
# Bracket the function call with
# tf.summary.trace_on() and tf.summary.trace_export().
tf.summary.trace_on(graph=True)
tf.profiler.experimental.start(logdir)
# Call only one tf.function when tracing.
z = print(new_model(tf.constant([[2.0, 2.0, 2.0]])))
with writer.as_default():
tf.summary.trace_export(
name="my_func_trace",
step=0,
profiler_outdir=logdir)
tf.Tensor([[0. 0.01750386]], shape=(1, 2), dtype=float32)
Avvia TensorBoard per visualizzare la traccia risultante:
#docs_infra: no_execute
%tensorboard --logdir logs/func
Creazione di un SavedModel
Il modo consigliato per condividere modelli completamente addestrati consiste nell'usare SavedModel . SavedModel contiene sia una raccolta di funzioni che una raccolta di pesi.
Puoi salvare il modello che hai appena addestrato come segue:
tf.saved_model.save(my_model, "the_saved_model")
INFO:tensorflow:Assets written to: the_saved_model/assets
# Inspect the SavedModel in the directoryls -l the_saved_model
total 24 drwxr-sr-x 2 kbuilder kokoro 4096 Oct 26 01:29 assets -rw-rw-r-- 1 kbuilder kokoro 14702 Oct 26 01:29 saved_model.pb drwxr-sr-x 2 kbuilder kokoro 4096 Oct 26 01:29 variables
# The variables/ directory contains a checkpoint of the variablesls -l the_saved_model/variables
total 8 -rw-rw-r-- 1 kbuilder kokoro 408 Oct 26 01:29 variables.data-00000-of-00001 -rw-rw-r-- 1 kbuilder kokoro 356 Oct 26 01:29 variables.index
Il file saved_model.pb è un buffer di protocollo che descrive il funzionale tf.Graph .
Modelli e livelli possono essere caricati da questa rappresentazione senza creare effettivamente un'istanza della classe che l'ha creata. Ciò è auspicabile in situazioni in cui non si dispone (o si desidera) un interprete Python, come servire su larga scala o su un dispositivo perimetrale, o in situazioni in cui il codice Python originale non è disponibile o pratico da usare.
Puoi caricare il modello come nuovo oggetto:
new_model = tf.saved_model.load("the_saved_model")
new_model , creato dal caricamento di un modello salvato, è un oggetto utente TensorFlow interno senza alcuna conoscenza della classe. Non è di tipo SequentialModule .
isinstance(new_model, SequentialModule)
False
Questo nuovo modello funziona sulle firme di input già definite. Non puoi aggiungere più firme a un modello ripristinato in questo modo.
print(my_model([[2.0, 2.0, 2.0]]))
print(my_model([[[2.0, 2.0, 2.0], [2.0, 2.0, 2.0]]]))
tf.Tensor([[0.62891716 0. ]], shape=(1, 2), dtype=float32) tf.Tensor( [[[0.62891716 0. ] [0.62891716 0. ]]], shape=(1, 2, 2), dtype=float32)
Pertanto, utilizzando SavedModel , è possibile salvare pesi e grafici TensorFlow utilizzando tf.Module , quindi caricarli di nuovo.
Modelli e strati Keras
Nota che fino a questo punto non si fa menzione di Keras. Puoi creare la tua API di alto livello su tf.Module e le persone lo hanno fatto.
In questa sezione, esaminerai come Keras utilizza tf.Module . Una guida utente completa ai modelli Keras è disponibile nella guida Keras .
Strati di Keras
tf.keras.layers.Layer è la classe base di tutti i livelli Keras ed eredita da tf.Module .
Puoi convertire un modulo in un livello Keras semplicemente sostituendo il genitore e quindi cambiando __call__ in call :
class MyDense(tf.keras.layers.Layer):
# Adding **kwargs to support base Keras layer arguments
def __init__(self, in_features, out_features, **kwargs):
super().__init__(**kwargs)
# This will soon move to the build step; see below
self.w = tf.Variable(
tf.random.normal([in_features, out_features]), name='w')
self.b = tf.Variable(tf.zeros([out_features]), name='b')
def call(self, x):
y = tf.matmul(x, self.w) + self.b
return tf.nn.relu(y)
simple_layer = MyDense(name="simple", in_features=3, out_features=3)
I livelli Keras hanno il loro __call__ che fa alcune operazioni di contabilità descritte nella sezione successiva e quindi chiama call() . Non dovresti notare alcun cambiamento nella funzionalità.
simple_layer([[2.0, 2.0, 2.0]])
<tf.Tensor: shape=(1, 3), dtype=float32, numpy=array([[0. , 0.179402, 0. ]], dtype=float32)>
La fase build
Come notato, in molti casi è conveniente attendere per creare variabili finché non si è sicuri della forma di input.
I livelli Keras sono dotati di un passaggio aggiuntivo del ciclo di vita che ti consente una maggiore flessibilità nel modo in cui definisci i tuoi livelli. Questo è definito nella funzione build .
build viene chiamato esattamente una volta e viene chiamato con la forma dell'input. Di solito viene utilizzato per creare variabili (pesi).
Puoi riscrivere il livello MyDense sopra per essere flessibile alle dimensioni dei suoi input:
class FlexibleDense(tf.keras.layers.Layer):
# Note the added `**kwargs`, as Keras supports many arguments
def __init__(self, out_features, **kwargs):
super().__init__(**kwargs)
self.out_features = out_features
def build(self, input_shape): # Create the state of the layer (weights)
self.w = tf.Variable(
tf.random.normal([input_shape[-1], self.out_features]), name='w')
self.b = tf.Variable(tf.zeros([self.out_features]), name='b')
def call(self, inputs): # Defines the computation from inputs to outputs
return tf.matmul(inputs, self.w) + self.b
# Create the instance of the layer
flexible_dense = FlexibleDense(out_features=3)
A questo punto il modello non è stato costruito, quindi non ci sono variabili:
flexible_dense.variables
[]
La chiamata alla funzione alloca variabili di dimensioni appropriate:
# Call it, with predictably random results
print("Model results:", flexible_dense(tf.constant([[2.0, 2.0, 2.0], [3.0, 3.0, 3.0]])))
Model results: tf.Tensor( [[-1.6998017 1.6444504 -1.3103955] [-2.5497022 2.4666753 -1.9655929]], shape=(2, 3), dtype=float32)
flexible_dense.variables
[<tf.Variable 'flexible_dense/w:0' shape=(3, 3) dtype=float32, numpy=
array([[ 1.277462 , 0.5399406 , -0.301957 ],
[-1.6277349 , 0.7374014 , -1.7651852 ],
[-0.49962795, -0.45511687, 1.4119445 ]], dtype=float32)>,
<tf.Variable 'flexible_dense/b:0' shape=(3,) dtype=float32, numpy=array([0., 0., 0.], dtype=float32)>]
Poiché build viene chiamato solo una volta, gli input verranno rifiutati se la forma dell'input non è compatibile con le variabili del livello:
try:
print("Model results:", flexible_dense(tf.constant([[2.0, 2.0, 2.0, 2.0]])))
except tf.errors.InvalidArgumentError as e:
print("Failed:", e)
Failed: In[0] mismatch In[1] shape: 4 vs. 3: [1,4] [3,3] 0 0 [Op:MatMul]
I livelli Keras hanno molte più funzionalità extra tra cui:
- Perdite facoltative
- Supporto per le metriche
- Supporto integrato per un argomento di
trainingfacoltativo per distinguere tra utilizzo di addestramento e inferenza -
get_configefrom_configmetodi che consentono di archiviare accuratamente le configurazioni per consentire la clonazione del modello in Python
Leggi di loro nella guida completa ai livelli e ai modelli personalizzati.
Modelli Keras
Puoi definire il tuo modello come livelli Keras nidificati.
Tuttavia, Keras fornisce anche una classe modello completa denominata tf.keras.Model . Eredita da tf.keras.layers.Layer , quindi un modello Keras può essere utilizzato, nidificato e salvato allo stesso modo dei livelli Keras. I modelli Keras sono dotati di funzionalità extra che li rendono facili da addestrare, valutare, caricare, salvare e persino addestrare su più macchine.
Puoi definire il SequentialModule dall'alto con un codice quasi identico, convertendo ancora __call__ in call() e cambiando il genitore:
class MySequentialModel(tf.keras.Model):
def __init__(self, name=None, **kwargs):
super().__init__(**kwargs)
self.dense_1 = FlexibleDense(out_features=3)
self.dense_2 = FlexibleDense(out_features=2)
def call(self, x):
x = self.dense_1(x)
return self.dense_2(x)
# You have made a Keras model!
my_sequential_model = MySequentialModel(name="the_model")
# Call it on a tensor, with random results
print("Model results:", my_sequential_model(tf.constant([[2.0, 2.0, 2.0]])))
Model results: tf.Tensor([[5.5604653 3.3511646]], shape=(1, 2), dtype=float32)
Sono disponibili tutte le stesse funzionalità, comprese le variabili di tracciamento e i sottomoduli.
my_sequential_model.variables
[<tf.Variable 'my_sequential_model/flexible_dense_1/w:0' shape=(3, 3) dtype=float32, numpy=
array([[ 0.05627853, -0.9386015 , -0.77410126],
[ 0.63149 , 1.0802224 , -0.37785745],
[-0.24788402, -1.1076807 , -0.5956209 ]], dtype=float32)>,
<tf.Variable 'my_sequential_model/flexible_dense_1/b:0' shape=(3,) dtype=float32, numpy=array([0., 0., 0.], dtype=float32)>,
<tf.Variable 'my_sequential_model/flexible_dense_2/w:0' shape=(3, 2) dtype=float32, numpy=
array([[-0.93912166, 0.77979285],
[ 1.4049559 , -1.9380962 ],
[-2.6039495 , 0.30885765]], dtype=float32)>,
<tf.Variable 'my_sequential_model/flexible_dense_2/b:0' shape=(2,) dtype=float32, numpy=array([0., 0.], dtype=float32)>]
my_sequential_model.submodules
(<__main__.FlexibleDense at 0x7f7b48525550>, <__main__.FlexibleDense at 0x7f7b48508d10>)
L'override tf.keras.Model è un approccio molto Pythonico alla creazione di modelli TensorFlow. Se stai migrando modelli da altri framework, questo può essere molto semplice.
Se stai costruendo modelli che sono semplici assemblaggi di livelli e input esistenti, puoi risparmiare tempo e spazio utilizzando l' API funzionale , che include funzionalità aggiuntive relative alla ricostruzione e all'architettura del modello.
Ecco lo stesso modello con l'API funzionale:
inputs = tf.keras.Input(shape=[3,])
x = FlexibleDense(3)(inputs)
x = FlexibleDense(2)(x)
my_functional_model = tf.keras.Model(inputs=inputs, outputs=x)
my_functional_model.summary()
Model: "model" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= input_1 (InputLayer) [(None, 3)] 0 _________________________________________________________________ flexible_dense_3 (FlexibleDe (None, 3) 12 _________________________________________________________________ flexible_dense_4 (FlexibleDe (None, 2) 8 ================================================================= Total params: 20 Trainable params: 20 Non-trainable params: 0 _________________________________________________________________
my_functional_model(tf.constant([[2.0, 2.0, 2.0]]))
<tf.Tensor: shape=(1, 2), dtype=float32, numpy=array([[8.219393, 4.511119]], dtype=float32)>
La differenza principale qui è che la forma di input è specificata in anticipo come parte del processo di costruzione funzionale. L'argomento input_shape in questo caso non deve essere specificato completamente; puoi lasciare alcune dimensioni come None .
Salvataggio dei modelli Keras
I modelli Keras possono essere sottoposti a checkpoint e sarà lo stesso di tf.Module .
I modelli Keras possono anche essere salvati con tf.saved_model.save() , poiché sono moduli. Tuttavia, i modelli Keras hanno metodi pratici e altre funzionalità:
my_sequential_model.save("exname_of_file")
INFO:tensorflow:Assets written to: exname_of_file/assets
Altrettanto facilmente, possono essere ricaricati in:
reconstructed_model = tf.keras.models.load_model("exname_of_file")
WARNING:tensorflow:No training configuration found in save file, so the model was *not* compiled. Compile it manually.
Keras SavedModels salva anche gli stati di metrica, perdita e ottimizzatore.
Questo modello ricostruito può essere utilizzato e produrrà lo stesso risultato quando richiamato sugli stessi dati:
reconstructed_model(tf.constant([[2.0, 2.0, 2.0]]))
<tf.Tensor: shape=(1, 2), dtype=float32, numpy=array([[5.5604653, 3.3511646]], dtype=float32)>
C'è altro da sapere sul salvataggio e la serializzazione dei modelli Keras, inclusa la fornitura di metodi di configurazione per livelli personalizzati per il supporto delle funzionalità. Consulta la guida al salvataggio e alla serializzazione .
Qual è il prossimo
Se vuoi conoscere maggiori dettagli su Keras, puoi seguire le guide Keras esistenti qui .
Un altro esempio di API di alto livello costruita su tf.module è Sonnet di DeepMind, che è trattato sul loro sito .