Salva e carica i modelli

TensorFlow.js fornisce funzionalità per il salvataggio e il caricamento modelli che sono stati creati con il Layers API o convertiti da modelli tensorflow esistenti. Questi possono essere modelli che hai addestrato tu stesso o quelli addestrati da altri. Un vantaggio chiave dell'utilizzo dell'API Layers è che i modelli creati con essa sono serializzabili e questo è ciò che esploreremo in questo tutorial.

Questo tutorial si concentrerà sul salvataggio e sul caricamento dei modelli TensorFlow.js (identificabili dai file JSON). Possiamo anche importare modelli TensorFlow Python. Il caricamento di questi modelli è trattato nei seguenti due tutorial:

Salva un modello tf

tf.Model e tf.Sequential entrambi forniscono una funzione model.save che consente di salvare la topologia e pesi di un modello.

  • Topologia: questo è un file che descrive l'architettura di un modello (cioè quali operazioni utilizza). Contiene riferimenti ai pesi dei modelli che sono memorizzati esternamente.

  • Pesi: sono file binari che memorizzano i pesi di un dato modello in un formato efficiente. Sono generalmente archiviati nella stessa cartella della topologia.

Diamo un'occhiata a come appare il codice per salvare un modello

const saveResult = await model.save('localstorage://my-model-1');

Alcune cose da notare:

  • Il save metodo prende un argomento di tipo stringa URL-like che inizia con uno schema. Questo descrive il tipo di destinazione in cui stiamo cercando di salvare un modello. Nell'esempio sopra lo schema è localstorage://
  • Lo schema è seguito da un percorso. Nell'esempio sopra il percorso è my-model-1 .
  • Il save metodo è asincrona.
  • Il valore restituito model.save è un oggetto JSON che trasporta informazioni quali i formati byte di topologia e pesi del modello.
  • L'ambiente utilizzato per salvare il modello non influisce sugli ambienti che possono caricare il modello. Il salvataggio di un modello in node.js non ne impedisce il caricamento nel browser.

Di seguito esamineremo i diversi schemi disponibili.

Archiviazione locale (solo browser)

Schema: localstorage://

await model.save('localstorage://my-model');

Ciò consente di risparmiare un modello sotto il nome di my-model in del browser di archiviazione locale . Ciò persisterà tra gli aggiornamenti, sebbene l'archiviazione locale possa essere cancellata dagli utenti o dal browser stesso se lo spazio diventa un problema. Ogni browser imposta anche il proprio limite sulla quantità di dati che possono essere archiviati nella memoria locale per un determinato dominio.

IndexedDB (solo browser)

Schema: indexeddb://

await model.save('indexeddb://my-model');

Ciò consente di risparmiare un modello del browser IndexedDB stoccaggio. Come l'archiviazione locale, persiste tra gli aggiornamenti, tende anche ad avere limiti maggiori sulla dimensione degli oggetti archiviati.

Download di file (solo browser)

Schema: downloads://

await model.save('downloads://my-model');

Ciò farà sì che il browser scarichi i file del modello sulla macchina dell'utente. Verranno prodotti due file:

  1. Un file di testo JSON chiamato [my-model].json , che porta la topologia e il riferimento al file di pesi descritto di seguito.
  2. Un file binario che porta i valori di peso denominati [my-model].weights.bin .

È possibile modificare il nome [my-model] per ottenere i file con un nome diverso.

Poiché i .json punti di file al .bin utilizzando un percorso relativo, i due file devono essere nella stessa cartella.

Richiesta HTTP(S)

Schema: http:// o https://

await model.save('http://model-server.domain/upload')

Questo creerà una richiesta web per salvare un modello su un server remoto. Dovresti avere il controllo di quel server remoto in modo da assicurarti che sia in grado di gestire la richiesta.

Il modello sarà inviata al server HTTP specificato tramite un POST richiesta. Il corpo del POST è nella multipart/form-data formato e costituito da due file

  1. Un file di testo JSON chiamato model.json , che porta la topologia e il riferimento ai pesi di file descritti di seguito.
  2. Un file binario che trasporta i valori di peso chiamato model.weights.bin .

Nota che il nome dei due file sarà sempre esattamente come specificato sopra (il nome è integrato nella funzione). Questo documento api contiene un frammento di codice Python che dimostra come si può usare il pallone framework web per gestire la richiesta ha avuto origine da save .

Spesso dovrai passare più argomenti o intestazioni di richiesta al tuo server HTTP (ad esempio per l'autenticazione o se vuoi specificare una cartella in cui salvare il modello). È possibile ottenere il controllo a grana fine su questi aspetti delle richieste da save sostituendo l'argomento stringa URL in tf.io.browserHTTPRequest . Questa API offre una maggiore flessibilità nel controllo delle richieste HTTP.

Per esempio:

await model.save(tf.io.browserHTTPRequest(
    'http://model-server.domain/upload',
    {method: 'PUT', headers: {'header_key_1': 'header_value_1'} }));

File system nativo (solo Node.js)

Schema: file://

await model.save('file:///path/to/my-model');

Durante l'esecuzione su Node.js abbiamo anche accesso diretto al filesystem e possiamo salvare i modelli lì. Il comando sopra salvare due file nel path specificato afer il scheme .

  1. Un file di testo JSON chiamato [model].json , che porta la topologia e il riferimento al file di pesi descritto di seguito.
  2. Un file binario che porta i valori di peso denominati [model].weights.bin .

Nota che il nome dei due file sarà sempre esattamente come specificato sopra (il nome è integrato nella funzione).

Caricamento di un modello tf

Dato un modello che è stato salvato utilizzando uno dei metodi sopra descritti, possiamo caricare utilizzando il tf.loadLayersModel API.

Diamo un'occhiata a come appare il codice per caricare un modello

const model = await tf.loadLayersModel('localstorage://my-model-1');

Alcune cose da notare:

  • Come model.save() , la loadLayersModel funzione prende un URL simile stringa argomento che inizia con uno schema. Questo descrive il tipo di destinazione da cui stiamo cercando di caricare un modello.
  • Lo schema è seguito da un percorso. Nell'esempio sopra il percorso è my-model-1 .
  • La stringa simile all'URL può essere sostituita da un oggetto che corrisponde all'interfaccia IOHandler.
  • Il tf.loadLayersModel() funzione è asincrona.
  • Il valore di ritorno di tf.loadLayersModel è tf.Model

Di seguito esamineremo i diversi schemi disponibili.

Archiviazione locale (solo browser)

Schema: localstorage://

const model = await tf.loadLayersModel('localstorage://my-model');

Questo carica un modello chiamato my-model dal browser di archiviazione locale .

IndexedDB (solo browser)

Schema: indexeddb://

const model = await tf.loadLayersModel('indexeddb://my-model');

Questo carica un modello dal browser IndexedDB stoccaggio.

HTTP(S)

Schema: http:// o https://

const model = await tf.loadLayersModel('http://model-server.domain/download/model.json');

Questo carica un modello da un endpoint http. Dopo aver caricato il json file di funzione farà le richieste di corrispondente .bin file che i json riferimenti ai file.

File system nativo (solo Node.js)

Schema: file://

const model = await tf.loadLayersModel('file://path/to/my-model/model.json');

Durante l'esecuzione su Node.js abbiamo anche accesso diretto al filesystem e possiamo caricare i modelli da lì. Si noti che nella chiamata di funzione sopra si fa riferimento al file model.json stesso (mentre durante il salvataggio si specifica una cartella). Il corrispondente .bin file (s) dovrebbe essere nella stessa cartella del json file.

Caricamento di modelli con IOhandlers

Se gli schemi di cui sopra non sono sufficienti per le vostre esigenze, è possibile implementare il comportamento di carico personalizzato con IOHandler . Uno IOHandler che TensorFlow.js fornisce è tf.io.browserFiles che permette agli utenti del browser di caricare file di modello nel browser. Vedere la documentazione di per ulteriori informazioni.

Salvataggio e caricamento di modelli con IOhandler personalizzati

Se gli schemi di cui sopra non sono sufficienti per il vostro carico o esigenze di risparmio è possibile implementare un comportamento serializzazione personalizzata mediante l'attuazione di un IOHandler .

Un IOHandler è un oggetto con un save e load metodo.

Il save funzione accetta un parametro che è una corrisponde alla ModelArtifacts dell'interfaccia e dovrebbe restituire una promessa che si risolve in un SaveResult oggetto.

Il load funzione non ha parametri e dovrebbe restituire una promessa che risolve in un ModelArtifacts oggetto. Questo è lo stesso oggetto che viene passato a save .

Vedere BrowserHTTPRequest per un esempio di come implementare un IOHandler.