Tensorflow: comment sauvegarder/restaurer un modèle?

après avoir formé un modèle à Tensorflow:

  1. Comment sauver le modèle appris?
  2. comment restaurer plus tard ce modèle sauvegardé?
387
demandé sur corning 2015-11-17 17:37:26
la source

16 ответов

de Nouveau et de façon plus simple: simple_save

beaucoup de bonne réponse, pour l'exhaustivité je vais ajouter mes 2 cents: simple_save . Aussi un exemple de code autonome utilisant L'API tf.data.Dataset .

Python 3 ; Tensorflow 1.7

import tensorflow as tf
from tensorflow.python.saved_model import tag_constants

with tf.Graph().as_default():
    with tf.Session as sess:
        ...

        # Saving
        inputs = {
            "batch_size_placeholder": batch_size_placeholder,
            "features_placeholder": features_placeholder,
            "labels_placeholder": labels_placeholder,
        }
        outputs = {"prediction": model_output}
        tf.saved_model.simple_save(
            sess, 'path/to/your/location/', inputs, outputs
        )

restauration:

graph = tf.Graph()
with restored_graph.as_default():
    with tf.Session as sess:
        tf.saved_model.loader.load(
            sess,
            [tag_constants.SERVING],
        'path/to/your/location/',
        )
        batch_size_placeholder = graph.get_tensor_by_name('batch_size_placeholder:0')
        features_placeholder = graph.get_tensor_by_name('features_placeholder:0')
        labels_placeholder = graph.get_tensor_by_name('labels_placeholder:0')
        prediction = restored_graph.get_tensor_by_name('dense/BiasAdd:0')

        sess.run(prediction, feed_dict={
            batch_size_placeholder: some_value,
            features_placeholder: some_other_value,
            labels_placeholder: another_value
        })

exemple autonome

Original blog post

le code suivant génère des données aléatoires pour la démonstration.

  1. nous commençons par créer les espaces réservés. Ils retiendront les données à l'exécution. D'eux, nous créons le Dataset et ensuite son Iterator . Nous obtenons l'itérateur est généré tenseur, appelé input_tensor , qui servira d'entrée à notre modèle.
  2. le le modèle lui-même est construit à partir de input_tensor : un RNN bidirectionnel basé sur GRU suivi d'un classificateur dense. Parce que pourquoi pas.
  3. la perte est une softmax_cross_entropy_with_logits , optimisée avec Adam . Après 2 époques (de 2 lots chacune), nous enregistrons le modèle "trained" avec tf.saved_model.simple_save . Si vous exécutez le code tel quel, alors le modèle sera sauvegardé dans un dossier appelé simple/ dans votre répertoire de travail actuel.
  4. dans un nouveau graphique, nous restaurons alors le modèle enregistré avec tf.saved_model.loader.load . Nous saisissons les espaces réservés et logits avec graph.get_tensor_by_name et le Iterator initialisant l'opération avec graph.get_operation_by_name .
  5. enfin, nous faisons une inférence pour les deux lots dans l'ensemble de données, et vérifions que le modèle sauvegardé et restauré donnent les mêmes valeurs. Ils ne!

Code:

import os
import shutil
import numpy as np
import tensorflow as tf
from tensorflow.python.saved_model import tag_constants


def model(graph, input_tensor):
    """Create the model which consists of
    a bidirectional rnn (GRU(10)) followed by a dense classifier

    Args:
        graph (tf.Graph): Tensors' graph
        input_tensor (tf.Tensor): Tensor fed as input to the model

    Returns:
        tf.Tensor: the model's output layer Tensor
    """
    cell = tf.nn.rnn_cell.GRUCell(10)
    with graph.as_default():
        ((fw_outputs, bw_outputs), (fw_state, bw_state)) = tf.nn.bidirectional_dynamic_rnn(
            cell_fw=cell,
            cell_bw=cell,
            inputs=input_tensor,
            sequence_length=[10] * 32,
            dtype=tf.float32,
            swap_memory=True,
            scope=None)
        outputs = tf.concat((fw_outputs, bw_outputs), 2)
        mean = tf.reduce_mean(outputs, axis=1)
        dense = tf.layers.dense(mean, 5, activation=None)

        return dense


def get_opt_op(graph, logits, labels_tensor):
    """Create optimization operation from model's logits and labels

    Args:
        graph (tf.Graph): Tensors' graph
        logits (tf.Tensor): The model's output without activation
        labels_tensor (tf.Tensor): Target labels

    Returns:
        tf.Operation: the operation performing a stem of Adam optimizer
    """
    with graph.as_default():
        with tf.variable_scope('loss'):
            loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
                    logits=logits, labels=labels_tensor, name='xent'),
                    name="mean-xent"
                    )
        with tf.variable_scope('optimizer'):
            opt_op = tf.train.AdamOptimizer(1e-2).minimize(loss)
        return opt_op


if __name__ == '__main__':
    # Set random seed for reproducibility
    # and create synthetic data
    np.random.seed(0)
    features = np.random.randn(64, 10, 30)
    labels = np.eye(5)[np.random.randint(0, 5, (64,))]

    graph1 = tf.Graph()
    with graph1.as_default():
        # Random seed for reproducibility
        tf.set_random_seed(0)
        # Placeholders
        batch_size_ph = tf.placeholder(tf.int64, name='batch_size_ph')
        features_data_ph = tf.placeholder(tf.float32, [None, None, 30], 'features_data_ph')
        labels_data_ph = tf.placeholder(tf.int32, [None, 5], 'labels_data_ph')
        # Dataset
        dataset = tf.data.Dataset.from_tensor_slices((features_data_ph, labels_data_ph))
        dataset = dataset.batch(batch_size_ph)
        iterator = tf.data.Iterator.from_structure(dataset.output_types, dataset.output_shapes)
        dataset_init_op = iterator.make_initializer(dataset, name='dataset_init')
        input_tensor, labels_tensor = iterator.get_next()

        # Model
        logits = model(graph1, input_tensor)
        # Optimization
        opt_op = get_opt_op(graph1, logits, labels_tensor)

        with tf.Session(graph=graph1) as sess:
            # Initialize variables
            tf.global_variables_initializer().run(session=sess)
            for epoch in range(3):
                batch = 0
                # Initialize dataset (could feed epochs in Dataset.repeat(epochs))
                sess.run(
                    dataset_init_op,
                    feed_dict={
                        features_data_ph: features,
                        labels_data_ph: labels,
                        batch_size_ph: 32
                    })
                values = []
                while True:
                    try:
                        if epoch < 2:
                            # Training
                            _, value = sess.run([opt_op, logits])
                            print('Epoch {}, batch {} | Sample value: {}'.format(epoch, batch, value[0]))
                            batch += 1
                        else:
                            # Final inference
                            values.append(sess.run(logits))
                            print('Epoch {}, batch {} | Final inference | Sample value: {}'.format(epoch, batch, values[-1][0]))
                            batch += 1
                    except tf.errors.OutOfRangeError:
                        break
            # Save model state
            print('\nSaving...')
            cwd = os.getcwd()
            path = os.path.join(cwd, 'simple')
            shutil.rmtree(path, ignore_errors=True)
            inputs_dict = {
                "batch_size_ph": batch_size_ph,
                "features_data_ph": features_data_ph,
                "labels_data_ph": labels_data_ph
            }
            outputs_dict = {
                "logits": logits
            }
            tf.saved_model.simple_save(
                sess, path, inputs_dict, outputs_dict
            )
            print('Ok')
    # Restoring
    graph2 = tf.Graph()
    with graph2.as_default():
        with tf.Session(graph=graph2) as sess:
            # Restore saved values
            print('\nRestoring...')
            tf.saved_model.loader.load(
                sess,
                [tag_constants.SERVING],
                path
            )
            print('Ok')
            # Get restored placeholders
            labels_data_ph = graph2.get_tensor_by_name('labels_data_ph:0')
            features_data_ph = graph2.get_tensor_by_name('features_data_ph:0')
            batch_size_ph = graph2.get_tensor_by_name('batch_size_ph:0')
            # Get restored model output
            restored_logits = graph2.get_tensor_by_name('dense/BiasAdd:0')
            # Get dataset initializing operation
            dataset_init_op = graph2.get_operation_by_name('dataset_init')

            # Initialize restored dataset
            sess.run(
                dataset_init_op,
                feed_dict={
                    features_data_ph: features,
                    labels_data_ph: labels,
                    batch_size_ph: 32
                }

            )
            # Compute inference for both batches in dataset
            restored_values = []
            for i in range(2):
                restored_values.append(sess.run(restored_logits))
                print('Restored values: ', restored_values[i][0])

    # Check if original inference and restored inference are equal
    valid = all((v == rv).all() for v, rv in zip(values, restored_values))
    print('\nInferences match: ', valid)

ce sera imprimé:

$ python3 save_and_restore.py

Epoch 0, batch 0 | Sample value: [-0.13851789 -0.3087595   0.12804556  0.20013677 -0.08229901]
Epoch 0, batch 1 | Sample value: [-0.00555491 -0.04339041 -0.05111827 -0.2480045  -0.00107776]
Epoch 1, batch 0 | Sample value: [-0.19321944 -0.2104792  -0.00602257  0.07465433  0.11674127]
Epoch 1, batch 1 | Sample value: [-0.05275984  0.05981954 -0.15913513 -0.3244143   0.10673307]
Epoch 2, batch 0 | Final inference | Sample value: [-0.26331693 -0.13013336 -0.12553    -0.04276478  0.2933622 ]
Epoch 2, batch 1 | Final inference | Sample value: [-0.07730117  0.11119192 -0.20817074 -0.35660955  0.16990358]

Saving...
INFO:tensorflow:Assets added to graph.
INFO:tensorflow:No assets to write.
INFO:tensorflow:SavedModel written to: b'/some/path/simple/saved_model.pb'
Ok

Restoring...
INFO:tensorflow:Restoring parameters from b'/some/path/simple/variables/variables'
Ok
Restored values:  [-0.26331693 -0.13013336 -0.12553    -0.04276478  0.2933622 ]
Restored values:  [-0.07730117  0.11119192 -0.20817074 -0.35660955  0.16990358]

Inferences match:  True
27
répondu ted 2018-06-14 11:10:10
la source

j'améliore ma réponse pour ajouter plus de détails pour sauvegarder et restaurer les modèles.

(et après) Tensorflow la version 0.11 :

Enregistrer le modèle:

import tensorflow as tf

#Prepare to feed input, i.e. feed_dict and placeholders
w1 = tf.placeholder("float", name="w1")
w2 = tf.placeholder("float", name="w2")
b1= tf.Variable(2.0,name="bias")
feed_dict ={w1:4,w2:8}

#Define a test operation that we will restore
w3 = tf.add(w1,w2)
w4 = tf.multiply(w3,b1,name="op_to_restore")
sess = tf.Session()
sess.run(tf.global_variables_initializer())

#Create a saver object which will save all the variables
saver = tf.train.Saver()

#Run the operation by feeding input
print sess.run(w4,feed_dict)
#Prints 24 which is sum of (w1+w2)*b1 

#Now, save the graph
saver.save(sess, 'my_test_model',global_step=1000)

restaurer le modèle:

import tensorflow as tf

sess=tf.Session()    
#First let's load meta graph and restore weights
saver = tf.train.import_meta_graph('my_test_model-1000.meta')
saver.restore(sess,tf.train.latest_checkpoint('./'))


# Access saved Variables directly
print(sess.run('bias:0'))
# This will print 2, which is the value of bias that we saved


# Now, let's access and create placeholders variables and
# create feed-dict to feed new data

graph = tf.get_default_graph()
w1 = graph.get_tensor_by_name("w1:0")
w2 = graph.get_tensor_by_name("w2:0")
feed_dict ={w1:13.0,w2:17.0}

#Now, access the op that you want to run. 
op_to_restore = graph.get_tensor_by_name("op_to_restore:0")

print sess.run(op_to_restore,feed_dict)
#This will print 60 which is calculated 

ceci et quelques cas d'utilisation plus avancés ont été très bien expliqués ici.

un tutoriel complet rapide pour enregistrer et restaurer les modèles Tensorflow

221
répondu sankit 2018-04-03 15:40:42
la source

(et après) TensorFlow la version 0.11.0RC1, vous pouvez sauvegarder et restaurer votre modèle directement en appelant tf.train.export_meta_graph et tf.train.import_meta_graph selon https://www.tensorflow.org/programmers_guide/meta_graph .

Enregistrer le modèle

w1 = tf.Variable(tf.truncated_normal(shape=[10]), name='w1')
w2 = tf.Variable(tf.truncated_normal(shape=[20]), name='w2')
tf.add_to_collection('vars', w1)
tf.add_to_collection('vars', w2)
saver = tf.train.Saver()
sess = tf.Session()
sess.run(tf.global_variables_initializer())
saver.save(sess, 'my-model')
# `save` method will call `export_meta_graph` implicitly.
# you will get saved graph files:my-model.meta

restaurer le modèle

sess = tf.Session()
new_saver = tf.train.import_meta_graph('my-model.meta')
new_saver.restore(sess, tf.train.latest_checkpoint('./'))
all_vars = tf.get_collection('vars')
for v in all_vars:
    v_ = sess.run(v)
    print(v_)
171
répondu lei du 2017-10-21 22:25:38
la source

pour la version TensorFlow < 0.11.0RC1:

les points de contrôle qui sont sauvegardés contiennent des valeurs pour les Variable dans votre modèle, pas le modèle/graphique lui-même, ce qui signifie que le graphique doit être le même lorsque vous restaurez le point de contrôle.

voici un exemple de régression linéaire où il y a une boucle d'entraînement qui sauve les points de contrôle variables et une section d'évaluation qui restaurera les variables sauvegardées lors d'un passage antérieur et calculera les prédictions. Bien sûr, vous pouvez également restaurer des variables et continuer la formation si vous le souhaitez.

x = tf.placeholder(tf.float32)
y = tf.placeholder(tf.float32)

w = tf.Variable(tf.zeros([1, 1], dtype=tf.float32))
b = tf.Variable(tf.ones([1, 1], dtype=tf.float32))
y_hat = tf.add(b, tf.matmul(x, w))

...more setup for optimization and what not...

saver = tf.train.Saver()  # defaults to saving all variables - in this case w and b

with tf.Session() as sess:
    sess.run(tf.initialize_all_variables())
    if FLAGS.train:
        for i in xrange(FLAGS.training_steps):
            ...training loop...
            if (i + 1) % FLAGS.checkpoint_steps == 0:
                saver.save(sess, FLAGS.checkpoint_dir + 'model.ckpt',
                           global_step=i+1)
    else:
        # Here's where you're restoring the variables w and b.
        # Note that the graph is exactly as it was when the variables were
        # saved in a prior training run.
        ckpt = tf.train.get_checkpoint_state(FLAGS.checkpoint_dir)
        if ckpt and ckpt.model_checkpoint_path:
            saver.restore(sess, ckpt.model_checkpoint_path)
        else:
            ...no checkpoint found...

        # Now you can run the model to get predictions
        batch_x = ...load some data...
        predictions = sess.run(y_hat, feed_dict={x: batch_x})

voici le docs pour Variable s, qui couvrent l'économie et la restauration. Et voici le docs pour le Saver .

122
répondu Ryan Sepassi 2017-12-12 12:25:34
la source

il y a deux parties au modèle, la définition du modèle, enregistré par Supervisor comme graph.pbtxt dans le répertoire du modèle et les valeurs numériques des tenseurs, enregistré dans les fichiers de contrôle comme model.ckpt-1003418 .

la définition du modèle peut être restaurée en utilisant tf.import_graph_def , et les poids sont restaurés en utilisant Saver .

cependant, Saver utilise une liste spéciale de variables qui est attachée au graphique du modèle, et cette collection n'est pas initialisée en utilisant import_graph_def, donc vous ne pouvez pas utiliser les deux ensemble pour le moment (c'est sur notre feuille de route pour corriger). Pour l'instant, vous devez utiliser l'approche de Ryan Sepassi -- construire manuellement un graphe avec des noms de noeuds identiques, et utiliser Saver pour charger les poids dans elle.

(alternativement vous pouvez le hacker en utilisant import_graph_def , en créant des variables manuellement, et en utilisant tf.add_to_collection(tf.GraphKeys.VARIABLES, variable) pour chaque variable, puis en utilisant Saver )

52
répondu Yaroslav Bulatov 2016-08-15 03:27:12
la source

mon environnement: Python 3.6, Tensorflow 1.3.0

bien qu'il y ait eu beaucoup de solutions, la plupart d'entre elles sont basées sur tf.train.Saver . Lorsque nous chargeons un .ckpt enregistré par Saver , nous devons soit redéfinir le réseau tensorflow ou utiliser un nom bizarre et difficile à retenir, par exemple 'placehold_0:0' , 'dense/Adam/Weight:0' . Ici je recommande d'utiliser tf.saved_model , un exemple le plus simple donné ci-dessous, vous pouvez apprendre plus de servir un modèle TensorFlow :

Enregistrer le modèle:

import tensorflow as tf

# define the tensorflow network and do some trains
x = tf.placeholder("float", name="x")
w = tf.Variable(2.0, name="w")
b = tf.Variable(0.0, name="bias")

h = tf.multiply(x, w)
y = tf.add(h, b, name="y")
sess = tf.Session()
sess.run(tf.global_variables_initializer())

# save the model
export_path =  './savedmodel'
builder = tf.saved_model.builder.SavedModelBuilder(export_path)

tensor_info_x = tf.saved_model.utils.build_tensor_info(x)
tensor_info_y = tf.saved_model.utils.build_tensor_info(y)

prediction_signature = (
  tf.saved_model.signature_def_utils.build_signature_def(
      inputs={'x_input': tensor_info_x},
      outputs={'y_output': tensor_info_y},
      method_name=tf.saved_model.signature_constants.PREDICT_METHOD_NAME))

builder.add_meta_graph_and_variables(
  sess, [tf.saved_model.tag_constants.SERVING],
  signature_def_map={
      tf.saved_model.signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY:
          prediction_signature 
  },
  )
builder.save()

chargez le modèle:

import tensorflow as tf
sess=tf.Session() 
signature_key = tf.saved_model.signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY
input_key = 'x_input'
output_key = 'y_output'

export_path =  './savedmodel'
meta_graph_def = tf.saved_model.loader.load(
           sess,
          [tf.saved_model.tag_constants.SERVING],
          export_path)
signature = meta_graph_def.signature_def

x_tensor_name = signature[signature_key].inputs[input_key].name
y_tensor_name = signature[signature_key].outputs[output_key].name

x = sess.graph.get_tensor_by_name(x_tensor_name)
y = sess.graph.get_tensor_by_name(y_tensor_name)

y_out = sess.run(y, {x: 3.0})
51
répondu Tom 2017-12-20 12:33:49
la source

vous pouvez également prendre cette voie plus facile.

Étape 1: initialiser toutes vos variables

W1 = tf.Variable(tf.truncated_normal([6, 6, 1, K], stddev=0.1), name="W1")
B1 = tf.Variable(tf.constant(0.1, tf.float32, [K]), name="B1")

Similarly, W2, B2, W3, .....

Étape 2: Enregistrer la session à l'intérieur du modèle Saver et l'enregistrer

model_saver = tf.train.Saver()

# Train the model and save it in the end
model_saver.save(session, "saved_models/CNN_New.ckpt")

Étape 3: restaurer le modèle

with tf.Session(graph=graph_cnn) as session:
    model_saver.restore(session, "saved_models/CNN_New.ckpt")
    print("Model restored.") 
    print('Initialized')

Étape 4: Cochez votre variable

W1 = session.run(W1)
print(W1)

utilisez

with tf.Session() as sess:
    # Restore latest checkpoint
    saver.restore(sess, tf.train.latest_checkpoint('saved_model/.'))

    # Initalize the variables
    sess.run(tf.global_variables_initializer())

    # Get default graph (supply your custom graph if you have one)
    graph = tf.get_default_graph()

    # It will give tensor object
    W1 = graph.get_tensor_by_name('W1:0')

    # To get the value (numpy array)
    W1_value = session.run(W1)
36
répondu Himanshu Babal 2017-10-21 22:19:14
la source

dans la plupart des cas, sauvegarder et restaurer à partir du disque en utilisant un tf.train.Saver est votre meilleure option:

... # build your model
saver = tf.train.Saver()

with tf.Session() as sess:
    ... # train the model
    saver.save(sess, "/tmp/my_great_model")

with tf.Session() as sess:
    saver.restore(sess, "/tmp/my_great_model")
    ... # use the model

vous pouvez également sauvegarder/restaurer la structure du graphique elle-même (voir la documentation Metagraphique pour plus de détails). Par défaut ,le Saver sauvegarde la structure du graphique dans un fichier .meta . Vous pouvez appeler import_meta_graph() pour le restaurer. Il restaure la structure graphique et renvoie un Saver que vous pouvez utiliser pour restaurer l' l'état du modèle:

saver = tf.train.import_meta_graph("/tmp/my_great_model.meta")

with tf.Session() as sess:
    saver.restore(sess, "/tmp/my_great_model")
    ... # use the model

cependant, il y a des cas où vous avez besoin de quelque chose de beaucoup plus rapide. Par exemple, si vous implémentez l'arrêt précoce, vous voulez sauver les points de contrôle chaque fois que le modèle s'améliore pendant la formation (tel que mesuré sur le jeu de validation), alors s'il n'y a pas de progrès pendant un certain temps, vous voulez revenir au meilleur modèle. Si vous enregistrez le modèle sur disque à chaque fois qu'il améliore, il va énormément ralentir la formation. L'astuce est de sauver la variable États à mémoire , puis il suffit de les restaurer plus tard:

... # build your model

# get a handle on the graph nodes we need to save/restore the model
graph = tf.get_default_graph()
gvars = graph.get_collection(tf.GraphKeys.GLOBAL_VARIABLES)
assign_ops = [graph.get_operation_by_name(v.op.name + "/Assign") for v in gvars]
init_values = [assign_op.inputs[1] for assign_op in assign_ops]

with tf.Session() as sess:
    ... # train the model

    # when needed, save the model state to memory
    gvars_state = sess.run(gvars)

    # when needed, restore the model state
    feed_dict = {init_value: val
                 for init_value, val in zip(init_values, gvars_state)}
    sess.run(assign_ops, feed_dict=feed_dict)

une explication rapide: lorsque vous créez une variable X , TensorFlow crée automatiquement une opération d'affectation X/Assign pour définir la valeur initiale de la variable. Au lieu de créer des espaces réservés et des affectations supplémentaires (ce qui ne ferait que rendre le graphique confus), nous utilisons simplement ces affectations existantes. La première entrée de chaque opération d'affectation est une référence à la variable il est supposé initialiser, et la seconde entrée ( assign_op.inputs[1] ) est la valeur initiale. Donc, pour définir la valeur que nous voulons (au lieu de la valeur initiale), nous devons utiliser un feed_dict et remplacer la valeur initiale. Oui, TensorFlow vous permet d'alimenter une valeur pour n'importe quel op, pas seulement pour les placeholders, donc cela fonctionne très bien.

18
répondu MiniQuark 2017-10-21 22:16:56
la source

comme Yaroslav l'a dit, Vous pouvez Hacker la restauration à partir d'un graph_def et checkpoint en important le graphe, en créant manuellement des variables, puis en utilisant un épargnant.

j'ai implémenté ceci pour mon usage personnel, donc j'ai pensé partager le code ici.

lien: https://gist.github.com/nikitakit/6ef3b72be67b86cb7868

(ceci est, bien sûr, un hack, et il n'y a aucune garantie que les modèles enregistrés de cette façon restez lisible dans les versions futures de TensorFlow.)

16
répondu nikitakit 2016-01-05 13:35:14
la source

S'il s'agit d'un modèle sauvegardé en interne, vous n'avez qu'à spécifier un restaurateur pour toutes les variables comme

restorer = tf.train.Saver(tf.all_variables())

et l'utiliser pour restaurer des variables dans une session en cours:

restorer.restore(self._sess, model_file)

pour le modèle externe, vous devez spécifier la correspondance entre les noms de ses variables et vos noms de variables. Vous pouvez voir les noms des variables du modèle en utilisant la commande

python /path/to/tensorflow/tensorflow/python/tools/inspect_checkpoint.py --file_name=/path/to/pretrained_model/model.ckpt

le inspect_checkpoint.py script peut être trouvé dans './tensorflow/python/outils " dossier de la Tensorflow source.

pour spécifier la correspondance, vous pouvez utiliser mon TensorFlow-Worklab , qui contient un ensemble de classes et de scripts pour former et recycler différents modèles. Il comprend un exemple de reconversion modèles ResNet, situé ici

13
répondu Sergey Demyanov 2016-07-04 10:32:49
la source

voici ma solution simple pour les deux cas de base différant selon que vous voulez charger le graphique à partir du fichier ou le construire pendant l'exécution.

cette réponse vaut pour Tensorflow 0.12+ (y compris 1.0).

reconstruction du graphe dans le code

Sauver

graph = ... # build the graph
saver = tf.train.Saver()  # create the saver after the graph
with ... as sess:  # your session object
    saver.save(sess, 'my-model')

Chargement

graph = ... # build the graph
saver = tf.train.Saver()  # create the saver after the graph
with ... as sess:  # your session object
    saver.restore(sess, tf.train.latest_checkpoint('./'))
    # now you can use the graph, continue training or whatever

Chargement aussi le graphique d'un fichier

En utilisant cette technique, assurez-vous que tous vos calques/variables ont explicitement défini des noms uniques. sinon Tensorflow rendra les noms uniques et ils seront donc différents des noms stockés dans le fichier. Ce n'est pas un problème dans la technique précédente, parce que les noms sont "mutilés" de la même façon dans le chargement et l'économie.

Sauver

graph = ... # build the graph

for op in [ ... ]:  # operators you want to use after restoring the model
    tf.add_to_collection('ops_to_restore', op)

saver = tf.train.Saver()  # create the saver after the graph
with ... as sess:  # your session object
    saver.save(sess, 'my-model')

Chargement

with ... as sess:  # your session object
    saver = tf.train.import_meta_graph('my-model.meta')
    saver.restore(sess, tf.train.latest_checkpoint('./'))
    ops = tf.get_collection('ops_to_restore')  # here are your operators in the same order in which you saved them to the collection
10
répondu Martin Pecka 2017-06-02 03:29:33
la source

vous pouvez également consulter exemples dans TensorFlow/skflow , qui offre des méthodes save et restore qui peuvent vous aider à gérer facilement vos modèles. Il a des paramètres que vous pouvez également contrôler la fréquence à laquelle vous souhaitez sauvegarder votre modèle.

9
répondu Yuan Tang 2016-02-17 06:21:03
la source

si vous utilisez tf.train.MonitoredTrainingSession comme la session par défaut, vous n'avez pas besoin d'ajouter du code supplémentaire pour faire enregistrer/restaurer des choses. Il suffit de passer un nom de dir checkpoint pour Monitoredtrainingsession's constructor, il utilisera des crochets de session pour gérer ces.

7
répondu Changming Sun 2017-05-20 18:35:09
la source

tel qu'il est décrit dans la 6255 :

use '**./**model_name.ckpt'
saver.restore(sess,'./my_model_final.ckpt')

au lieu de

saver.restore('my_model_final.ckpt')
6
répondu user7505159 2017-02-02 13:04:17
la source

toutes les réponses ici sont grandes, mais je veux ajouter deux choses.

tout d'abord, pour développer la réponse de @user7505159, le "./" peut être important à ajouter au début du nom de fichier à restaurer.

Par exemple, vous pouvez enregistrer un graphe non "./" dans le nom de fichier comme ceci:

# Some graph defined up here with specific names

saver = tf.train.Saver()
save_file = 'model.ckpt'

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    saver.save(sess, save_file)

mais pour restaurer le graphe, vous devrez peut-être préparer un "./" nom_fichier:

# Same graph defined up here

saver = tf.train.Saver()
save_file = './' + 'model.ckpt' # String addition used for emphasis

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    saver.restore(sess, save_file)

Vous n'aurez pas toujours besoin "./ ", mais il peut causer des problèmes en fonction de votre environnement et la version de TensorFlow.

il souhaite également mentionner que le sess.run(tf.global_variables_initializer()) peut être important avant de restaurer la session.

si vous recevez une erreur concernant des variables non initialisées lorsque vous essayez de restaurer une session sauvegardée, assurez-vous d'inclure sess.run(tf.global_variables_initializer()) avant la ligne saver.restore(sess, save_file) . Il peut vous faire économiser des maux de tête.

6
répondu saetch_g 2017-06-27 02:03:01
la source

le mode "Eager" est aussi une question non résolue de sauvegarde / restauration à laquelle personne n'a répondu, même pas la documentation en fait, bien que les docs prétendent certainement répondre. Voici le code non-working que j'ai écrit qui essaye d'utiliser la classe Saver à l'intérieur de tensorflow.contrib.impatient comme tfe. Mon code est définitivement enregistré sur disque... quelque chose a été enregistré. Le problème, c'est la restauration. J'ai même ajouté du code explicite pour d'abord recréer manuellement tout et ensuite charger les paramètres appris:

optimizer = tf.train.AdamOptimizer() #ga
global_step = tf.train.get_or_create_global_step()  # what is a global_step?
model = tf.keras.Sequential([
  tf.keras.layers.Dense(10, activation=tf.nn.relu, input_shape=(4,)),  # input shape required
  tf.keras.layers.Dense(10, activation=tf.nn.relu, kernel_initializer='glorot_uniform'),
  tf.keras.layers.Dense(3)
])
#s = tfe.Saver([optimizer, model, global_step])
s = tfe.Saver([model])
s.restore(file_prefix="/tmp/iris-1")

il restaure quelque chose puis jette une Valeurerreur:

INFO:tensorflow:Restoring parameters from /tmp/iris-1

---------------------------------------------------------------------------
ValueError...
--> names, slices, dtypes = zip(*restore_specs) 
-1
répondu Geoffrey Anderson 2018-09-26 21:34:33
la source

Autres questions sur