¿Cómo guardar/restaurar un modelo después del entrenamiento?

23 minutos de lectura

¿Como guardarrestaurar un modelo despues del entrenamiento
matemáticos

Después de entrenar un modelo en Tensorflow:

  1. ¿Cómo se guarda el modelo entrenado?
  2. ¿Cómo restauras más tarde este modelo guardado?

  • ¿Pudo restaurar las variables utilizadas en el modelo inicial? También estoy intentando exactamente el mismo problema, pero no puedo escribir un conjunto de variables que se usaron mientras entrenaba el modelo de inicio (del cual tengo el archivo ckpt)

    – exAres

    11/10/2016 a las 17:52

  • No he probado con el modelo de inicio. ¿Tienes la estructura de red del modelo con sus nombres? Tienes que replicar la red y luego cargar los pesos y sesgos (el archivo ckpt) como explica Ryan. Tal vez algo ha cambiado desde el 15 de noviembre y ahora hay un enfoque más sencillo, no estoy seguro.

    – matemáticos

    11/10/2016 a las 18:22


  • Oh, está bien. He cargado otros modelos de flujo de tensor previamente entrenados, pero estaba buscando especificaciones variables del modelo de inicio. Gracias.

    – exAres

    11/10/2016 a las 18:30

  • Si restaura para continuar entrenando, solo use los puntos de control de Saver. Si guarda el modelo para hacer referencia, solo las API del modelo guardado de tensorflow.

    – HYG

    20 de diciembre de 2017 a las 9:28

  • Además, si está utilizando LSTM, tendrá un mapa de cadena a una lista de caracteres, ¡asegúrese de guardar y cargar esa lista en el mismo orden! Esto no se cubre al guardar los pesos del modelo y la red de gráficos del modelo y hará que parezca que su modelo no se cargó cuando cambia de sesión o cuando cambian los datos.

    – devssh

    26 de septiembre de 2018 a las 6:02


¿Como guardarrestaurar un modelo despues del entrenamiento
sankit

Estoy mejorando mi respuesta para agregar más detalles para guardar y restaurar modelos.

en (y después) Tensorflow versión 0.11:

Guarde el modelo:

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)

Restaurar el modelo:

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 

Este y algunos casos de uso más avanzados se han explicado muy bien aquí.

Un tutorial rápido y completo para guardar y restaurar modelos de Tensorflow

  • +1 para esto # Acceder directamente a las variables guardadas print(sess.run(‘bias:0’)) # Esto imprimirá 2, que es el valor del sesgo que guardamos. Ayuda mucho para fines de depuración para ver si el modelo se carga correctamente. las variables se pueden obtener con “All_varaibles = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES” . Además, “sess.run(tf.global_variables_initializer())” debe estar antes de la restauración.

    – LGG

    16 de mayo de 2017 a las 0:08


  • ¿Estás seguro de que tenemos que ejecutar global_variables_initializer nuevamente? Restauré mi gráfico con global_variable_initialization, y me da un resultado diferente cada vez con los mismos datos. Así que comenté la inicialización y simplemente restauré el gráfico, la variable de entrada y las operaciones, y ahora funciona bien.

    – Aditya Shinde

    04/06/2017 a las 20:44

  • @AdityaShinde No entiendo por qué siempre obtengo valores diferentes cada vez. Y no incluí el paso de inicialización de variables para restaurar. Estoy usando mi propio código por cierto.

    – Cadena

    7 de junio de 2017 a las 9:35

  • @AdityaShinde: no necesita init op ya que los valores ya están inicializados por la función de restauración, así que elimínelo. Sin embargo, no estoy seguro de por qué obtuvo un resultado diferente al usar init op.

    – Sankit

    8 de junio de 2017 a las 6:11

  • @sankit Cuando restauras los tensores, ¿por qué agregas :0 a los nombres?

    –Sahar Rabinoviz

    13 de julio de 2017 a las 0:18

¿Como guardarrestaurar un modelo despues del entrenamiento
ley du

En (y después) TensorFlow versión 0.11.0RC1, puede guardar y restaurar su modelo directamente llamando tf.train.export_meta_graph y tf.train.import_meta_graph de acuerdo a https://www.tensorflow.org/programmers_guide/meta_graph.

Guardar el modelo

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

restaurar el modelo

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_)

  • ¿Cómo cargar variables del modelo guardado? ¿Cómo copiar valores en alguna otra variable?

    – Neel

    19 de diciembre de 2016 a las 8:58

  • No puedo hacer que este código funcione. El modelo se guarda pero no puedo restaurarlo. Me esta dando este error. <built-in function TF_Run> returned a result with an error set

    – Saad Qureshi

    8 de enero de 2017 a las 9:05


  • Cuando después de restaurar accedo a las variables como se muestra arriba, funciona. Pero no puedo obtener las variables más directamente usando tf.get_variable_scope().reuse_variables() seguido por var = tf.get_variable("varname"). Esto me da el error: “ValueError: la variable varname no existe o no se creó con tf.get_variable()”. ¿Por qué? ¿No debería ser esto posible?

    – jpp1

    12 de enero de 2017 a las 14:16

  • Esto funciona bien solo para las variables, pero ¿cómo puede obtener acceso a un marcador de posición y alimentarlo con valores después de restaurar el gráfico?

    – kbrose

    29 de marzo de 2017 a las 16:09

  • Esto solo muestra cómo restaurar las variables. ¿Cómo puede restaurar todo el modelo y probarlo con nuevos datos sin redefinir la red?

    – Cadena

    6 de junio de 2017 a las 19:26

1646966302 848 ¿Como guardarrestaurar un modelo despues del entrenamiento
ted

Documentos de Tensorflow 2

Guardar puntos de control

Adaptado de los documentos

# -------------------------
# -----  Toy Context  -----
# -------------------------
import tensorflow as tf


class Net(tf.keras.Model):
    """A simple linear model."""

    def __init__(self):
        super(Net, self).__init__()
        self.l1 = tf.keras.layers.Dense(5)

    def call(self, x):
        return self.l1(x)


def toy_dataset():
    inputs = tf.range(10.0)[:, None]
    labels = inputs * 5.0 + tf.range(5.0)[None, :]
    return (
        tf.data.Dataset.from_tensor_slices(dict(x=inputs, y=labels)).repeat().batch(2)
    )


def train_step(net, example, optimizer):
    """Trains `net` on `example` using `optimizer`."""
    with tf.GradientTape() as tape:
        output = net(example["x"])
        loss = tf.reduce_mean(tf.abs(output - example["y"]))
    variables = net.trainable_variables
    gradients = tape.gradient(loss, variables)
    optimizer.apply_gradients(zip(gradients, variables))
    return loss


# ----------------------------
# -----  Create Objects  -----
# ----------------------------

net = Net()
opt = tf.keras.optimizers.Adam(0.1)
dataset = toy_dataset()
iterator = iter(dataset)
ckpt = tf.train.Checkpoint(
    step=tf.Variable(1), optimizer=opt, net=net, iterator=iterator
)
manager = tf.train.CheckpointManager(ckpt, "./tf_ckpts", max_to_keep=3)

# ----------------------------
# -----  Train and Save  -----
# ----------------------------

ckpt.restore(manager.latest_checkpoint)
if manager.latest_checkpoint:
    print("Restored from {}".format(manager.latest_checkpoint))
else:
    print("Initializing from scratch.")

for _ in range(50):
    example = next(iterator)
    loss = train_step(net, example, opt)
    ckpt.step.assign_add(1)
    if int(ckpt.step) % 10 == 0:
        save_path = manager.save()
        print("Saved checkpoint for step {}: {}".format(int(ckpt.step), save_path))
        print("loss {:1.2f}".format(loss.numpy()))


# ---------------------
# -----  Restore  -----
# ---------------------

# In another script, re-initialize objects
opt = tf.keras.optimizers.Adam(0.1)
net = Net()
dataset = toy_dataset()
iterator = iter(dataset)
ckpt = tf.train.Checkpoint(
    step=tf.Variable(1), optimizer=opt, net=net, iterator=iterator
)
manager = tf.train.CheckpointManager(ckpt, "./tf_ckpts", max_to_keep=3)

# Re-use the manager code above ^

ckpt.restore(manager.latest_checkpoint)
if manager.latest_checkpoint:
    print("Restored from {}".format(manager.latest_checkpoint))
else:
    print("Initializing from scratch.")

for _ in range(50):
    example = next(iterator)
    # Continue training or evaluate etc.

Más enlaces

Los puntos de control capturan el valor exacto de todos los parámetros (objetos tf.Variable) utilizados por un modelo. Los puntos de control no contienen ninguna descripción del cálculo definido por el modelo. y, por lo tanto, normalmente solo son útiles cuando el código fuente que usará los valores de parámetros guardados está disponible.

El formato SavedModel por otro lado incluye una descripción serializada del cálculo definido por el modelo además de los valores de los parámetros (punto de control). Los modelos en este formato son independiente del código fuente que creó el modelo. Por lo tanto, son adecuados para su implementación a través de TensorFlow Serving, TensorFlow Lite, TensorFlow.js o programas en otros lenguajes de programación (C, C++, Java, Go, Rust, C#, etc. API de TensorFlow).

(Los puntos destacados son míos)


Flujo de tensor < 2


De los documentos:

Salvar

# Create some variables.
v1 = tf.get_variable("v1", shape=[3], initializer = tf.zeros_initializer)
v2 = tf.get_variable("v2", shape=[5], initializer = tf.zeros_initializer)

inc_v1 = v1.assign(v1+1)
dec_v2 = v2.assign(v2-1)

# Add an op to initialize the variables.
init_op = tf.global_variables_initializer()

# Add ops to save and restore all the variables.
saver = tf.train.Saver()

# Later, launch the model, initialize the variables, do some work, and save the
# variables to disk.
with tf.Session() as sess:
  sess.run(init_op)
  # Do some work with the model.
  inc_v1.op.run()
  dec_v2.op.run()
  # Save the variables to disk.
  save_path = saver.save(sess, "/tmp/model.ckpt")
  print("Model saved in path: %s" % save_path)

Restaurar

tf.reset_default_graph()

# Create some variables.
v1 = tf.get_variable("v1", shape=[3])
v2 = tf.get_variable("v2", shape=[5])

# Add ops to save and restore all the variables.
saver = tf.train.Saver()

# Later, launch the model, use the saver to restore variables from disk, and
# do some work with the model.
with tf.Session() as sess:
  # Restore variables from disk.
  saver.restore(sess, "/tmp/model.ckpt")
  print("Model restored.")
  # Check the values of the variables
  print("v1 : %s" % v1.eval())
  print("v2 : %s" % v2.eval())

simple_save

Muchas buenas respuestas, para completar agregaré mis 2 centavos: simple_guardar. También un ejemplo de código independiente usando el tf.data.Dataset API.

pitón 3; tensorflow 1.14

import tensorflow as tf
from tensorflow.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
        )

Restauración:

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
        })

ejemplo independiente

Publicación de blog original

El siguiente código genera datos aleatorios por el bien de la demostración.

  1. Comenzamos creando los marcadores de posición. Mantendrán los datos en tiempo de ejecución. A partir de ellos, creamos el Dataset y luego es Iterator. Obtenemos el tensor generado por el iterador, llamado input_tensor que servirá como entrada a nuestro modelo.
  2. El modelo en sí está construido a partir de input_tensor: un RNN bidireccional basado en GRU seguido de un clasificador denso. Porque, porque no.
  3. La pérdida es un softmax_cross_entropy_with_logitsoptimizado con Adam. Después de 2 épocas (de 2 lotes cada una), guardamos el modelo “entrenado” con tf.saved_model.simple_save. Si ejecuta el código tal como está, el modelo se guardará en una carpeta llamada simple/ en su directorio de trabajo actual.
  4. En un nuevo gráfico, luego restauramos el modelo guardado con tf.saved_model.loader.load. Tomamos los marcadores de posición y los logits con graph.get_tensor_by_name y el Iterator operación de inicialización con graph.get_operation_by_name.
  5. Por último, ejecutamos una inferencia para ambos lotes en el conjunto de datos y comprobamos que el modelo guardado y el restaurado arrojan los mismos valores. ¡Ellas hacen!

Código:

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)

Esto imprimirá:

$ 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

  • Soy principiante y necesito más explicaciones…: Si tengo un modelo de CNN, ¿debería almacenar solo 1. input_placeholder 2. labels_placeholder y 3. output_of_cnn? O todos los intermedios tf.contrib.layers?

    – Lloviendo

    16 de junio de 2018 a las 11:43

  • El gráfico está completamente restaurado. Podrías comprobarlo funcionando [n.name for n in graph2.as_graph_def().node]. Como dice la documentación, el guardado simple tiene como objetivo simplificar la interacción con el servicio de tensorflow, este es el punto de los argumentos; sin embargo, otras variables aún se restauran; de lo contrario, no se produciría la inferencia. Simplemente tome sus variables de interés como lo hice en el ejemplo. Revisar la documentación

    – Ted

    16 de junio de 2018 a las 12:25


  • Bien, supongo, pero ¿funciona también con modelos en modo Eager y tfe.Saver?

    – Geoffrey Anderson

    26 sep 2018 a las 18:47

  • sin global_step como argumento, si se detiene y luego intenta retomar el entrenamiento nuevamente, pensará que es un paso uno. Arruinará tus visualizaciones de tensorboard como mínimo

    – Mónica Heddneck

    20 de abril de 2019 a las 1:00

  • Estoy tratando de llamar a restaurar y obtengo este error ValueError: No variables to save. ¿Alguien puede ayudar?

    – Elaine Chen

    9 de marzo de 2020 a las 20:38

1646966303 144 ¿Como guardarrestaurar un modelo despues del entrenamiento
Ryan Sepassi

Para la versión de TensorFlow < 0.11.0RC1:

Los puntos de control que se guardan contienen valores para el Variables en su modelo, no en el modelo/gráfico en sí, lo que significa que el gráfico debe ser el mismo cuando restaure el punto de control.

Este es un ejemplo de una regresión lineal en la que hay un bucle de entrenamiento que guarda los puntos de control de las variables y una sección de evaluación que restaurará las variables guardadas en una ejecución anterior y calculará las predicciones. Por supuesto, también puede restaurar variables y continuar entrenando si lo desea.

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})

Aquí están los documentos por Variables, que cubren el ahorro y la restauración. Y aquí están los documentos Para el Saver.

1646966304 293 ¿Como guardarrestaurar un modelo despues del entrenamiento
Tomás

Mi entorno: Python 3.6, Tensorflow 1.3.0

Aunque ha habido muchas soluciones, la mayoría de ellas se basan en tf.train.Saver. Cuando cargamos un .ckpt salvado por Savertenemos que redefinir la red tensorflow o usar algún nombre extraño y difícil de recordar, por ejemplo 'placehold_0:0','dense/Adam/Weight:0'. Aquí recomiendo usar tf.saved_modelun ejemplo más simple dado a continuación, puede aprender más de Servir un modelo de TensorFlow:

Guarde el modelo:

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()

Cargue el modelo:

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})

  • +1 para un gran ejemplo de la API de modelo guardado. Sin embargo, deseo su Guardar el modelo ¡La sección mostró un ciclo de entrenamiento como la respuesta de Ryan Sepassi! Me doy cuenta de que esta es una vieja pregunta, pero esta respuesta es uno de los pocos (y valiosos) ejemplos de modelo guardado que encontré en Google.

    – Dylan F.

    26 de diciembre de 2017 a las 3:07

  • @Tom, esta es una gran respuesta, solo una dirigida al nuevo modelo guardado. ¿Podría echar un vistazo a esta pregunta de modelo guardado? stackoverflow.com/questions/48540744/…

    – veranos azules

    11 de febrero de 2018 a las 15:10

  • Ahora haz que todo funcione correctamente con los modelos TF Eager. Google aconsejó en su presentación de 2018 que todos se alejaran del código gráfico TF.

    – Geoffrey Anderson

    26/09/2018 a las 18:50

1645724591 587 Android guardarrestaurar el estado del fragmento
David Silva Barrera

Hay dos partes en el modelo, la definición del modelo, guardada por Supervisor como graph.pbtxt en el directorio del modelo y los valores numéricos de los tensores, guardados en archivos de punto de control como model.ckpt-1003418.

La definición del modelo se puede restaurar usando tf.import_graph_defy los pesos se restablecen usando Saver.

Sin embargo, Saver usa una colección especial que contiene una lista de variables que se adjunta al modelo Graph, y esta colección no se inicializa con import_graph_def, por lo que no puede usar los dos juntos en este momento (está en nuestra hoja de ruta para arreglar). Por ahora, debe usar el enfoque de Ryan Sepassi: construya manualmente un gráfico con nombres de nodo idénticos y use Saver para cargar las pesas en él.

(Alternativamente, podría hackearlo usando usando import_graph_defcreando variables manualmente y usando tf.add_to_collection(tf.GraphKeys.VARIABLES, variable) para cada variable, luego usando Saver)

  • +1 para un gran ejemplo de la API de modelo guardado. Sin embargo, deseo su Guardar el modelo ¡La sección mostró un ciclo de entrenamiento como la respuesta de Ryan Sepassi! Me doy cuenta de que esta es una vieja pregunta, pero esta respuesta es uno de los pocos (y valiosos) ejemplos de modelo guardado que encontré en Google.

    – Dylan F.

    26 de diciembre de 2017 a las 3:07

  • @Tom, esta es una gran respuesta, solo una dirigida al nuevo modelo guardado. ¿Podría echar un vistazo a esta pregunta de modelo guardado? stackoverflow.com/questions/48540744/…

    – veranos azules

    11 de febrero de 2018 a las 15:10

  • Ahora haz que todo funcione correctamente con los modelos TF Eager. Google aconsejó en su presentación de 2018 que todos se alejaran del código gráfico TF.

    – Geoffrey Anderson

    26/09/2018 a las 18:50

1646966305 111 ¿Como guardarrestaurar un modelo despues del entrenamiento
hermano

También puede tomar esta forma más fácil.

Paso 1: inicializa todas tus 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, .....

Paso 2: guarda la sesión dentro del modelo Saver y guárdalo

model_saver = tf.train.Saver()

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

Paso 3: restaurar el modelo

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

Paso 4: comprueba tu variable

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

Mientras se ejecuta en una instancia de python diferente, use

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)

  • Hola, ¿cómo puedo guardar el modelo después de suponer 3000 iteraciones, similar a Caffe? Descubrí que tensorflow guarda solo los últimos modelos a pesar de que concateno el número de iteración con el modelo para diferenciarlo entre todas las iteraciones. Me refiero a model_3000.ckpt, model_6000.ckpt, — model_100000.ckpt. ¿Puede explicar amablemente por qué no guarda todo sino que guarda solo las últimas 3 iteraciones?

    – khan

    4 de abril de 2017 a las 10:32

  • @khan ver stackoverflow.com/questions/38265061/…

    – Himanshu Babal

    14/04/2017 a las 21:28

  • ¿Existe algún método para guardar todas las variables/nombres de operación dentro del gráfico?

    – Moondra

    11/10/2017 a las 17:36

¿Ha sido útil esta solución?

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con sus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, acepta el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Configurar y más información
Privacidad