TensorFlow: guardar y restaurar modelos

    El entrenamiento de un modelo de red neuronal profunda puede llevar bastante tiempo, dependiendo de la complejidad de su modelo, la cantidad de datos que tenga, el hardware en el que est茅 ejecutando sus modelos, etc. su progreso a un archivo, por lo que en caso de interrupci贸n (o un error), podr谩 continuar donde lo dej贸.

    Es m谩s, despu茅s de un entrenamiento exitoso, seguramente necesitar谩 reutilizar los par谩metros aprendidos del modelo para hacer predicciones sobre nuevos datos. Este es el caso de cualquier plataforma de aprendizaje profundo, como TensorFlow.

    En esta publicaci贸n, analizamos c贸mo guardar y restaurar un modelo de TensorFlow, que describimos algunas de las opciones m谩s 煤tiles en el camino y proporcionamos algunos ejemplos.

    Introducci贸n r谩pida del modelo de TensorFlow

    La funcionalidad principal de TensorFlow se entrega a trav茅s de tensores, su estructura de datos b谩sica similar a las matrices multidimensionales en NumPy, y gr谩ficos, que representan los c谩lculos sobre los datos. Es una biblioteca simb贸lica, lo que significa que definir un gr谩fico y tensores solo crear铆a un modelo, mientras que los tensores obtienen valores concretos y las operaciones se ejecutan dentro de una sesi贸n, un mecanismo para ejecutar las operaciones modeladas en un gr谩fico. Cualquier valor concreto de los tensores se pierde cuando se cierra una sesi贸n, que es otra raz贸n para guardar sus modelos en un archivo despu茅s de ejecutar una sesi贸n.

    Siempre es m谩s f谩cil de entender a trav茅s de ejemplos, as铆 que creemos un modelo de TensorFlow simple para la regresi贸n lineal de datos bidimensionales.

    Primero, importaremos nuestras bibliotecas:

    import tensorflow as tf
    import numpy as np
    import matplotlib.pyplot as plt
    %matplotlib inline
    

    El siguiente paso es crear el modelo. Generaremos un modelo que estimar谩 el desplazamiento horizontal y vertical de una funci贸n cuadr谩tica en la forma:

    y = (x - h) ^ 2 + v
    

    d贸nde h y v son los desplazamientos horizontales y verticales.

    Las siguientes l铆neas generan el modelo (consulte los comentarios en el c贸digo para obtener m谩s detalles):

    # Clear the current graph in each run, to avoid variable duplication
    tf.reset_default_graph()
    
    # Create placeholders for the x and y points
    X = tf.placeholder("float")
    Y = tf.placeholder("float")
    
    # Initialize the two parameters that need to be learned
    h_est = tf.Variable(0.0, name="hor_estimate")
    v_est = tf.Variable(0.0, name="ver_estimate")
    
    # y_est holds the estimated values on y-axis
    y_est = tf.square(X - h_est) + v_est
    
    # Define a cost function as the squared distance between Y and y_est
    cost = (tf.pow(Y - y_est, 2))
    
    # The training operation for minimizing the cost function. The
    # learning rate is 0.001
    trainop = tf.train.GradientDescentOptimizer(0.001).minimize(cost)
    

    En este punto tenemos el modelo que necesita ejecutarse en un Sesi贸n, pas谩ndole algunos datos reales. Generemos algunos datos cuadr谩ticos de ejemplo y agreguemos ruido.

    # Use some values for the horizontal and vertical shift
    h = 1
    v = -2
    
    # Generate training data with noise
    x_train = np.linspace(-2,4,201)
    noise = np.random.randn(*x_train.shape) * 0.4
    y_train = (x_train - h) ** 2 + v + noise
    
    # Visualize the data 
    plt.rcParams['figure.figsize'] = (10, 6)
    plt.scatter(x_train, y_train)
    plt.xlabel('x_train')
    plt.ylabel('y_train')
    

    La clase Saver

    los Saver La clase proporcionada por la biblioteca de TensorFlow es la forma recomendada de guardar la estructura y las variables del gr谩fico.

    Guardar modelos

    En las siguientes l铆neas, definimos un Saver objeto y dentro del train_graph() m茅todo, pasamos por 100 iteraciones para minimizar la funci贸n de costo. Luego, el modelo se guarda en el disco en cada iteraci贸n, as铆 como una vez finalizada la optimizaci贸n. Cada guardado crea archivos binarios en el disco llamados “puntos de control”.

    # Create a Saver object
    saver = tf.train.Saver()
    
    init = tf.global_variables_initializer()
    
    # Run a session. Go through 100 iterations to minimize the cost
    def train_graph():
        with tf.Session() as sess:
            sess.run(init)
            for i in range(100):
                for (x, y) in zip(x_train, y_train):
                    
                    # Feed actual data to the train operation
                    sess.run(trainop, feed_dict={X: x, Y: y})
                
                # Create a checkpoint in every iteration
                saver.save(sess, 'model_iter', global_step=i)
            
            # Save the final model
            saver.save(sess, 'model_final')
            h_ = sess.run(h_est)
            v_ = sess.run(v_est)
        return h_, v_
    

    Ahora entrenemos el modelo con la funci贸n anterior e imprimamos los par谩metros aprendidos.

    result = train_graph()
    print("h_est = %.2f, v_est = %.2f" % result)
    
    $ python tf_save.py
    h_est = 1.01, v_est = -1.96
    

    Bien, los par谩metros se estimaron con bastante precisi贸n. Si revisamos nuestro sistema de archivos, hay archivos guardados para las 煤ltimas 4 iteraciones, as铆 como el modelo final.

    Al guardar el modelo, notar谩 que se necesitan 4 tipos de archivos para guardarlo:

    • Archivos “.meta”: que contienen la estructura del gr谩fico
    • Archivos “.data”: que contienen los valores de las variables
    • Archivos “.index”: identificaci贸n del punto de control
    • archivo “punto de control”: un b煤fer de protocolo con una lista de puntos de control recientes

    Figura 1: Archivos de punto de control guardados en disco

    Llamando al tf.train.Saver() El m茅todo, como se muestra arriba, guardar铆a todas las variables en un archivo. Es posible guardar un subconjunto de sus variables pas谩ndolas como un argumento a trav茅s de una lista o un diccionario, por ejemplo: tf.train.Saver({'hor_estimate': h_est}).

    Algunos otros argumentos 煤tiles del Saver constructor, que permiten el control de todo el proceso, son:

    • max_to_keep: n煤mero m谩ximo de puntos de control a mantener,
    • keep_checkpoint_every_n_hours: un intervalo de tiempo para guardar puntos de control

    Para obtener m谩s informaci贸n, consulte el documentaci贸n oficial Para el Saver class, que ofrece otros argumentos 煤tiles que puede explorar.

    Restaurar modelos

    Lo primero que debe hacer al restaurar un modelo de TensorFlow es cargar la estructura del gr谩fico desde el archivo “.meta” en el gr谩fico actual.

    tf.reset_default_graph()
    imported_meta = tf.train.import_meta_graph("model_final.meta")
    

    El gr谩fico actual se puede explorar usando el siguiente comando tf.get_default_graph(). Ahora, el segundo paso es cargar los valores de las variables.

    Un recordatorio: los valores solo existen dentro de una sesi贸n.

    with tf.Session() as sess:
        imported_meta.restore(sess, tf.train.latest_checkpoint('./'))
        h_est2 = sess.run('hor_estimate:0')
        v_est2 = sess.run('ver_estimate:0')
        print("h_est: %.2f, v_est: %.2f" % (h_est2, v_est2))
    
    $ python tf_restore.py
    INFO:tensorflow:Restoring parameters from ./model_final
    h_est: 1.01, v_est: -1.96
    

    Como se mencion贸 anteriormente, este enfoque guarda solo la estructura del gr谩fico y las variables, lo que significa que los datos de entrenamiento que se ingresan a trav茅s de nuestros marcadores de posici贸n ‘X’ e ‘Y’ no se guardan.

    De todos modos, para este ejemplo usaremos nuestros datos de entrenamiento definidos a partir de tfy visualice el ajuste del modelo.

    plt.scatter(x_train, y_train, label="train data")
    plt.plot(x_train, (x_train - h_est2) ** 2 + v_est2, color="red", label="model")
    plt.xlabel('x_train')
    plt.ylabel('y_train')
    plt.legend()
    

    Como conclusi贸n para esta parte, el Saver La clase permite una manera f谩cil de guardar y restaurar su modelo de TensorFlow (gr谩fico y variables) a / desde un archivo, y mantener m煤ltiples puntos de control de su trabajo, lo que podr铆a ser 煤til para probar su modelo con datos nuevos, continuar entrenando y mejorar a煤n m谩s. Afinaci贸n.

    El formato de modelo guardado

    Un nuevo enfoque para guardar y restaurar un modelo en TensorFlow es usar el Modelo, constructor y cargador guardados funcionalidad. Esto realmente envuelve el Saver class para proporcionar una serializaci贸n de nivel superior, que es m谩s adecuada para fines de producci贸n.

    Mientras que la SavedModel El enfoque parece no ser completamente aceptado por los desarrolladores todav铆a, sus creadores se帽alan que es claramente el futuro. En comparaci贸n con el Saver clase, que se centra principalmente en variables, SavedModel intenta abarcar muchas caracter铆sticas 煤tiles en un paquete, como Signatures, que permiten guardar gr谩ficos que tienen un conjunto de entradas y salidas, y Assets que contiene archivos externos utilizados en la inicializaci贸n.

    Guardar modelos con SavedModel Builder

    El guardado de un modelo se realiza mediante el SavedModelBuilder clase. En nuestro ejemplo no utilizamos firmas ni activos, pero es suficiente para ilustrar el proceso.

    tf.reset_default_graph()
    
    # Re-initialize our two variables
    h_est = tf.Variable(h_est2, name="hor_estimate2")
    v_est = tf.Variable(v_est2, name="ver_estimate2")
    
    # Create a builder
    builder = tf.saved_model.builder.SavedModelBuilder('./SavedModel/')
    
    # Add graph and variables to builder and save
    with tf.Session() as sess:
        sess.run(h_est.initializer)
        sess.run(v_est.initializer)
        builder.add_meta_graph_and_variables(sess,
                                           [tf.saved_model.tag_constants.TRAINING],
                                           signature_def_map=None,
                                           assets_collection=None)
    builder.save()
    
    $ python tf_saved_model_builder.py
    INFO:tensorflow:No assets to save.
    INFO:tensorflow:No assets to write.
    INFO:tensorflow:SavedModel written to: b'./SavedModel/saved_model.pb'
    

    Al ejecutar este c贸digo, notar谩 que nuestro modelo se guarda en el archivo ubicado en “./SavedModel/saved_model.pb”.

    Restauraci贸n de modelos con SavedModel Loader

    La restauraci贸n del modelo se realiza utilizando el tf.saved_model.loader y restaura las variables, firmas y activos guardados en el 谩mbito de una sesi贸n.

    En el siguiente ejemplo, cargaremos el modelo e imprimiremos los valores de nuestros dos coeficientes h_est y v_est.

    with tf.Session() as sess:
        tf.saved_model.loader.load(sess, [tf.saved_model.tag_constants.TRAINING], './SavedModel/')
        h_est = sess.run('hor_estimate2:0')
        v_est = sess.run('ver_estimate2:0')
        print("h_est: %.2f, v_est: %.2f" % (h_est, v_est))
    
    $ python tf_saved_model_loader.py
    INFO:tensorflow:Restoring parameters from b'./SavedModel/variables/variables'
    h_est: 1.01, v_est: -1.96
    

    Y nuevamente, como se esperaba, nuestro modelo se restaur贸 con 茅xito con los par谩metros entrenados correctos.

    Conclusi贸n

    Guardar y restaurar un modelo de TensorFlow es una caracter铆stica muy 煤til, sabiendo que el entrenamiento de redes profundas puede llevar mucho tiempo. El tema es demasiado amplio para cubrirlo en detalle en una sola publicaci贸n de blog, por lo que es posible que lo revisemos en una publicaci贸n futura.

    De todos modos, en este post presentamos dos herramientas: la b谩sica Saver clase que guarda el modelo en forma de puntos de control, y el SavedModel builder/loader que se basa en Saver y crea una estructura de archivos que es f谩cil de usar en producci贸n. Se utiliz贸 una regresi贸n lineal simple para ilustrar los ejemplos.

     

    Etiquetas:

    Deja una respuesta

    Tu direcci贸n de correo electr贸nico no ser谩 publicada. Los campos obligatorios est谩n marcados con *