Questa pagina è stata tradotta dall'API Cloud Translation.
Switch to English

Formato hub TF1

Al suo lancio nel 2018, TensorFlow Hub offriva un unico tipo di risorsa: il formato TF1 Hub per l'importazione nei programmi TensorFlow 1.

Questa pagina spiega come utilizzare il formato hub TF1 in TF1 (o la modalità di compatibilità TF1 di TF2) con la classe hub.Module e le API associate. (L'uso tipico è quello di costruire un tf.Graph , possibilmente all'interno di uno Estimator TF1, combinando uno o più modelli in formato TF1 Hub con tf.compat.layers o tf.layers ).

Gli utenti di TensorFlow 2 (al di fuori della modalità di compatibilità TF1) devono utilizzare la nuova API con hub.load() o hub.KerasLayer . La nuova API carica il nuovo tipo di risorsa TF2 SavedModel, ma ha anche un supporto limitato per il caricamento del formato dell'hub TF1 in TF2 .

Utilizzo di un modello in formato TF1 Hub

Creare un'istanza di un modello nel formato hub TF1

Un modello in formato TF1 Hub viene importato in un programma TensorFlow creando un oggetto hub.Module da una stringa con il suo URL o percorso del filesystem, come:

 m = hub.Module("path/to/a/module_dir")
 

Ciò aggiunge le variabili del modulo al grafico TensorFlow corrente. L'esecuzione dei loro inizializzatori leggerà i loro valori pre-addestrati dal disco. Allo stesso modo, le tabelle e gli altri stati vengono aggiunti al grafico.

Moduli di memorizzazione nella cache

Quando si crea un modulo da un URL, il contenuto del modulo viene scaricato e memorizzato nella directory temporanea del sistema locale. La posizione in cui i moduli sono memorizzati nella cache può essere sovrascritta usando la variabile d'ambiente TFHUB_CACHE_DIR . Per i dettagli, consultare Memorizzazione nella cache .

Applicazione di un modulo

Una volta istanziato, un modulo m può essere chiamato zero o più volte come una funzione Python dagli ingressi tensore alle uscite tensore:

 y = m(x)
 

Ciascuna di queste chiamate aggiunge operazioni al grafico TensorFlow corrente per calcolare y da x . Se ciò comporta variabili con pesi allenati, queste sono condivise tra tutte le applicazioni.

I moduli possono definire più firme denominate per consentire l'applicazione in più di un modo (simile a come gli oggetti Python hanno metodi ). La documentazione di un modulo dovrebbe descrivere le firme disponibili. La chiamata precedente applica la firma denominata "default" . Qualsiasi firma può essere selezionata passando il suo nome all'argomento opzionale signature= .

Se una firma ha più input, devono essere passati come dict, con le chiavi definite dalla firma. Allo stesso modo, se una firma ha più output, questi possono essere recuperati come dict passando as_dict=True , sotto le chiavi definite dalla firma (la chiave "default" è per il singolo output restituito se as_dict=False ). Quindi la forma più generale di applicazione di un modulo è simile a:

 outputs = m(dict(apples=x1, oranges=x2), signature="fruit_to_pet", as_dict=True)
y1 = outputs["cats"]
y2 = outputs["dogs"]
 

Un chiamante deve fornire tutti gli ingressi definiti da una firma, ma non è necessario utilizzare tutte le uscite di un modulo. TensorFlow eseguirà solo quelle parti del modulo che finiscono come dipendenze di una destinazione in tf.Session.run() . In effetti, gli editori di moduli possono scegliere di fornire vari output per usi avanzati (come attivazioni di livelli intermedi) insieme agli output principali. Gli utenti dei moduli dovrebbero gestire con precisione output aggiuntivi.

Prova di moduli alternativi

Ogni volta che ci sono più moduli per lo stesso compito, TensorFlow Hub incoraggia a dotarli di insegne compatibili (interfacce) in modo tale che provarne di diversi sia facile quanto variare la gestione del modulo come un iperparametro a valore di stringa.

A tal fine, manteniamo una raccolta di firme comuni consigliate per le attività più diffuse.

Creazione di un nuovo modulo

Nota di compatibilità

Il formato dell'hub TF1 è orientato verso TensorFlow 1. È supportato solo parzialmente dall'hub TF in TensorFlow 2. Si consiglia invece di pubblicare nel nuovo formato SavedModel TF2 .

Il formato dell'hub TF1 è simile al formato SavedModel di TensorFlow 1 a livello sintattico (stessi nomi di file e messaggi di protocollo) ma semanticamente diverso per consentire il riutilizzo, la composizione e la riqualificazione dei moduli (ad esempio, diversa memorizzazione di inizializzatori di risorse, tag diversi convenzioni per i paragrafi). Il modo più semplice per distinguerli sul disco è la presenza o l'assenza del file tfhub_module.pb .

Approccio generale

Per definire un nuovo modulo, un editore chiama hub.create_module_spec() con una funzione module_fn . Questa funzione costruisce un grafico che rappresenta la struttura interna del modulo, usando tf.placeholder() per gli input che devono essere forniti dal chiamante. Quindi definisce le firme chiamando hub.add_signature(name, inputs, outputs) una o più volte.

Per esempio:

 def module_fn():
  inputs = tf.placeholder(dtype=tf.float32, shape=[None, 50])
  layer1 = tf.layers.dense(inputs, 200)
  layer2 = tf.layers.dense(layer1, 100)
  outputs = dict(default=layer2, hidden_activations=layer1)
  # Add default signature.
  hub.add_signature(inputs=inputs, outputs=outputs)

...
spec = hub.create_module_spec(module_fn)
 

Il risultato di hub.create_module_spec() può essere utilizzato, anziché un percorso, per creare un'istanza di un oggetto modulo all'interno di un particolare grafico TensorFlow. In tal caso, non esiste un punto di controllo e l'istanza del modulo utilizzerà invece gli inizializzatori di variabili.

Qualsiasi istanza del modulo può essere serializzata su disco tramite il suo metodo di export(path, session) . L'esportazione di un modulo serializza la sua definizione insieme allo stato corrente delle sue variabili nella session nel percorso passato. Questo può essere usato quando si esporta un modulo per la prima volta, nonché quando si esporta un modulo messo a punto.

Per compatibilità con gli hub.LatestModuleExporter TensorFlow, hub.LatestModuleExporter esporta i moduli dall'ultimo checkpoint, proprio come tf.estimator.LatestExporter esporta l'intero modello dall'ultimo checkpoint.

Gli editori di moduli dovrebbero implementare una firma comune quando possibile, in modo che i consumatori possano facilmente scambiare moduli e trovare quello migliore per il loro problema.

Vero esempio

Dai un'occhiata al nostro esportatore di moduli per l' incorporamento del testo per un esempio reale di come creare un modulo da un formato di incorporamento del testo comune.

Ritocchi

L'addestramento delle variabili di un modulo importato insieme a quelle del modello attorno ad esso è chiamato messa a punto . La messa a punto può migliorare la qualità, ma aggiunge nuove complicazioni. Consigliamo ai consumatori di esaminare la messa a punto solo dopo aver esplorato le modifiche di qualità più semplici e solo se l'editore del modulo lo consiglia.

Per i consumatori

Per attivare la messa a punto, istanziare il modulo con hub.Module(..., trainable=True) per rendere le sue variabili addestrabile e l'importazione di tensorflow REGULARIZATION_LOSSES . Se il modulo ha più varianti di grafici, assicurati di scegliere quello appropriato per l'allenamento. Di solito, è quello con i tag {"train"} .

Scegli un regime di allenamento che non rovini i pesi pre-allenati, ad esempio un tasso di apprendimento inferiore rispetto all'allenamento da zero.

Per gli editori

Per semplificare la messa a punto dei consumatori, tenere presente quanto segue:

  • La messa a punto deve essere regolarizzata. Il tuo modulo viene esportato con la raccolta REGULARIZATION_LOSSES , che è ciò che mette la tua scelta di tf.layers.dense(..., kernel_regularizer=...) ecc. In ciò che il consumatore ottiene da tf.losses.get_regularization_losses() . Preferire questo modo di definire le perdite di regolarizzazione L1 / L2.

  • Nel modello di editore, evitare di definire la regolarizzazione L1 / L2 tramite i parametri l1_ e l2_regularization_strength di tf.train.FtrlOptimizer , tf.train.ProximalGradientDescentOptimizer e altri ottimizzatori prossimali. Questi non vengono esportati insieme al modulo e l'impostazione dei punti di forza della regolarizzazione a livello globale potrebbe non essere appropriata per il consumatore. Fatta eccezione per la regolarizzazione L1 nei modelli wide (ovvero sparse linear) o wide & deep, dovrebbe invece essere possibile utilizzare perdite di regolarizzazione individuali.

  • Se si utilizzano dropout, normalizzazione batch o tecniche di allenamento simili, impostare i loro iperparametri su valori che hanno senso in molti usi previsti. Potrebbe essere necessario adeguare il tasso di abbandono alla propensione del problema target a un eccesso di adattamento. Nella normalizzazione batch, il momento (noto anche come coefficiente di decadimento) dovrebbe essere abbastanza piccolo da consentire la regolazione fine con set di dati piccoli e / o batch di grandi dimensioni. Per i consumatori avanzati, prendere in considerazione l'aggiunta di una firma che espone il controllo sugli iperparametri critici.