Cette page a été traduite par l'API Cloud Translation.
Switch to English

Enregistrer et charger des modèles

TensorFlow.js fournit des fonctionnalités pour enregistrer et charger des modèles qui ont été créés avec l'API Layers ou convertis à partir de modèles TensorFlow existants. Il peut s'agir de modèles que vous avez formés vous-même ou de ceux formés par d'autres. Un avantage clé de l'utilisation de l'API Layers est que les modèles créés avec elle sont sérialisables et c'est ce que nous explorerons dans ce tutoriel.

Ce tutoriel se concentrera sur l'enregistrement et le chargement des modèles TensorFlow.js (identifiables par les fichiers JSON). Nous pouvons également importer des modèles TensorFlow Python. Le chargement de ces modèles est couvert dans les deux didacticiels suivants:

Enregistrer un tf.Model

tf.Model et tf.Sequential fournissent tous deux une fonction model.save qui vous permet d'enregistrer la topologie et les poids d'un modèle.

  • Topologie: il s'agit d'un fichier décrivant l'architecture d'un modèle (c'est-à-dire les opérations qu'il utilise). Il contient des références aux poids des modèles qui sont stockés en externe.

  • Poids: ce sont des fichiers binaires qui stockent les poids d'un modèle donné dans un format efficace. Ils sont généralement stockés dans le même dossier que la topologie.

Jetons un œil à ce à quoi ressemble le code pour enregistrer un modèle

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

Quelques points à noter:

  • La méthode save prend un argument de chaîne de type URL qui commence par un schéma . Ceci décrit le type de destination dans lequel nous essayons d'enregistrer un modèle. Dans l'exemple ci-dessus, le schéma est localstorage://
  • Le schéma est suivi d'un chemin . Dans l'exemple ci-dessus, le chemin est my-model-1 .
  • La méthode save est asynchrone.
  • La valeur de retour de model.save est un objet JSON qui transporte des informations telles que les tailles d'octets de la topologie et des poids du modèle.
  • L'environnement utilisé pour enregistrer le modèle n'a pas d'incidence sur les environnements pouvant charger le modèle. L'enregistrement d'un modèle dans node.js n'empêche pas son chargement dans le navigateur.

Ci-dessous, nous examinerons les différents schémas disponibles.

Stockage local (navigateur uniquement)

Schéma: localstorage://

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

Cela enregistre un modèle sous le nom my-model dans le stockage local du navigateur. Cela persistera entre les actualisations, bien que le stockage local puisse être effacé par les utilisateurs ou le navigateur lui-même si l'espace devient un problème. Chaque navigateur définit également sa propre limite de quantité de données pouvant être stockées dans le stockage local pour un domaine donné.

IndexedDB (navigateur uniquement)

Schéma: indexeddb://

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

Cela enregistre un modèle dans le stockage IndexedDB du navigateur. Tout comme le stockage local, il persiste entre les actualisations, il a également tendance à avoir des limites plus importantes sur la taille des objets stockés.

Téléchargements de fichiers (navigateur uniquement)

Schéma: downloads://

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

Cela obligera le navigateur à télécharger les fichiers de modèle sur la machine de l'utilisateur. Deux fichiers seront produits:

  1. Un fichier texte JSON nommé [my-model].json , qui contient la topologie et la référence au fichier de pondérations décrit ci-dessous.
  2. Un fichier binaire contenant les valeurs de poids nommé [my-model].weights.bin .

Vous pouvez changer le nom [my-model] pour obtenir des fichiers avec un nom différent.

Étant donné que le fichier .json pointe vers le .bin aide d'un chemin d'accès relatif, les deux fichiers doivent se trouver dans le même dossier.

Requête HTTP (S)

Schéma: http:// ou https://

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

Cela créera une requête Web pour enregistrer un modèle sur un serveur distant. Vous devez avoir le contrôle de ce serveur distant afin de pouvoir vous assurer qu'il est capable de traiter la demande.

Le modèle sera envoyé au serveur HTTP spécifié via une requête POST . Le corps du POST est au format multipart/form-data et se compose de deux fichiers

  1. Un fichier texte JSON nommé model.json , qui contient la topologie et la référence au fichier de pondérations décrit ci-dessous.
  2. Un fichier binaire contenant les valeurs de poids nommé model.weights.bin .

Notez que le nom des deux fichiers sera toujours exactement comme spécifié ci-dessus (le nom est intégré à la fonction). Ce document api contient un extrait de code Python qui montre comment utiliser le framework web flask pour gérer la requête provenant de save .

Souvent, vous devrez passer plus d'arguments ou d'en-têtes de requête à votre serveur HTTP (par exemple pour l'authentification ou si vous souhaitez spécifier un dossier dans lequel le modèle doit être enregistré). Vous pouvez obtenir un contrôle précis sur ces aspects des demandes de save en remplaçant l'argument de chaîne URL dans tf.io.browserHTTPRequest . Cette API offre une plus grande flexibilité dans le contrôle des requêtes HTTP.

Par exemple:

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

Système de fichiers natif (Node.js uniquement)

Schéma: file://

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

Lors de l'exécution sur Node.js, nous avons également un accès direct au système de fichiers et pouvons y enregistrer des modèles. La commande ci-dessus enregistrera deux fichiers dans le path spécifié après le scheme .

  1. Un fichier texte JSON nommé [model].json , qui contient la topologie et la référence au fichier de pondérations décrit ci-dessous.
  2. Un fichier binaire contenant les valeurs de poids nommé [model].weights.bin .

Notez que le nom des deux fichiers sera toujours exactement comme spécifié ci-dessus (le nom est intégré à la fonction).

Chargement d'un tf.Model

Étant donné un modèle qui a été enregistré à l'aide de l'une des méthodes ci-dessus, nous pouvons le charger à l'aide de l'API tf.loadLayersModel .

Voyons à quoi ressemble le code de chargement d'un modèle

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

Quelques points à noter:

  • Comme model.save() , la fonction loadLayersModel prend un argument de chaîne de type URL qui commence par un schéma . Ceci décrit le type de destination à partir duquel nous essayons de charger un modèle.
  • Le schéma est suivi d'un chemin . Dans l'exemple ci-dessus, le chemin est my-model-1 .
  • La chaîne de type URL peut être remplacée par un objet qui correspond à l'interface IOHandler.
  • La fonction tf.loadLayersModel() est asynchrone.
  • La valeur de retour de tf.loadLayersModel est tf.Model

Ci-dessous, nous examinerons les différents schémas disponibles.

Stockage local (navigateur uniquement)

Schéma: localstorage://

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

Cela charge un modèle nommé my-model partir du stockage local du navigateur.

IndexedDB (navigateur uniquement)

Schéma: indexeddb://

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

Cela charge un modèle à partir du stockage IndexedDB du navigateur.

HTTP (S)

Schéma: http:// ou https://

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

Cela charge un modèle à partir d'un point de terminaison http. Après avoir chargé le fichier json , la fonction effectuera des requêtes pour les fichiers .bin correspondants auxquels le fichier json référence.

Système de fichiers natif (Node.js uniquement)

Schéma: file://

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

Lors de l'exécution sur Node.js, nous avons également un accès direct au système de fichiers et pouvons charger des modèles à partir de là. Notez que dans l'appel de fonction ci-dessus, nous référençons le fichier model.json lui-même (alors que lors de l'enregistrement, nous spécifions un dossier). Le ou les fichiers .bin correspondants doivent être dans le même dossier que le fichier json .

Chargement de modèles avec IOHandlers

Si les schémas ci-dessus ne sont pas suffisants pour vos besoins, vous pouvez implémenter un comportement de chargement personnalisé avec un IOHandler . Un IOHandler par TensorFlow.js est tf.io.browserFiles qui permet aux utilisateurs du navigateur de télécharger des fichiers de modèle dans le navigateur. Consultez la documentation pour plus d'informations.

Enregistrement et chargement de modèles avec des IOHandlers personnalisés

Si les schémas ci-dessus ne sont pas suffisants pour vos besoins de chargement ou d'enregistrement, vous pouvez implémenter un comportement de sérialisation personnalisé en implémentant un IOHandler .

Un IOHandler est un objet avec une méthode de save et de load .

La fonction de save prend un paramètre qui correspond à l'interface ModelArtifacts et doit renvoyer une promesse qui se résout en un objet SaveResult .

La fonction de load ne prend aucun paramètre et doit retourner une promesse qui se résout en un objet ModelArtifacts . C'est le même objet qui est passé pour save .

Voir BrowserHTTPRequest pour un exemple de la façon d'implémenter un IOHandler.