Capítulo 7: Aprendizaje profundo con TensorFlow
7.3 Guardar y Cargar Modelos en TensorFlow
Después de entrenar un modelo en TensorFlow, es crucial saber cómo guardarlo y cargarlo. Esto no solo le permite reutilizar su modelo en múltiples sesiones, sino que también facilita compartirlo con otros. Además, le permite guardar puntos de control de su modelo durante el entrenamiento, lo que puede ser útil en caso de interrupciones.
Otra ventaja de saber cómo guardar y cargar modelos es que le permite experimentar con diferentes arquitecturas de modelos y explorar diversas hiperparámetros sin tener que entrenar su modelo desde cero cada vez. Además, guardar modelos con diferentes configuraciones también puede servir como una forma de control de versiones, lo que le permite realizar un seguimiento de la evolución de su modelo a lo largo del tiempo y comparar diferentes versiones para ver cuáles funcionan mejor.
7.3.1 Guardar Modelos
TensorFlow proporciona una API simple pero completa para guardar y restaurar un modelo, que es un aspecto crucial de cualquier proyecto de aprendizaje automático. La clase tf.train.Saver es parte integral de esta API, ya que agrega las operaciones necesarias para guardar y restaurar variables desde y hacia puntos de control (checkpoints).
Al almacenar eficientemente las variables del modelo entrenado y sus valores correspondientes, la clase tf.train.Saver permite a los desarrolladores reutilizar y ajustar fácilmente sus modelos sin tener que volver a entrenarlos desde cero cada vez. La clase tf.train.Saver ofrece una serie de métodos de conveniencia que permiten a los desarrolladores ejecutar eficientemente estas operaciones, simplificando aún más el flujo de trabajo de creación e implementación de modelos de aprendizaje automático.
La clase tf.train.Saver es una herramienta esencial en el kit de herramientas del desarrollador de aprendizaje automático, que le permite ahorrar tiempo y recursos mientras construye modelos poderosos y escalables.
Ejemplo:
Aquí tienes un ejemplo de cómo guardar un modelo en TensorFlow:
import tensorflow as tf
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_regression
import numpy as np
# Generate a synthetic regression dataset
X_data, y_data = make_regression(n_samples=1000, n_features=10, noise=0.1, random_state=42)
# Split the dataset into training and validation sets
X_train, X_val, y_train, y_val = train_test_split(X_data, y_data, test_size=0.2, random_state=42)
# Define the number of inputs and outputs
n_inputs = 10
n_outputs = 1
# Build the neural network
X = tf.placeholder(tf.float32, shape=(None, n_inputs), name="X")
hidden = tf.layers.dense(X, n_inputs, name="hidden", activation=tf.nn.relu)
outputs = tf.layers.dense(hidden, n_outputs, name="outputs")
# Define the placeholder for the targets
y = tf.placeholder(tf.float32, shape=(None, n_outputs), name="y")
# Define the loss function
loss = tf.reduce_mean(tf.square(outputs - y)) # MSE
# Define the optimizer and the training operation
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)
training_op = optimizer.minimize(loss)
# Initialize the variables
init = tf.global_variables_initializer()
# Define the saver
saver = tf.train.Saver()
# Run the computation graph
with tf.Session() as sess:
sess.run(init)
for epoch in range(1000):
_, loss_value = sess.run([training_op, loss], feed_dict={X: X_train, y: y_train.reshape(-1, 1)})
if epoch % 100 == 0:
print("Epoch:", epoch, "\tLoss:", loss_value)
save_path = saver.save(sess, "/tmp/my_model.ckpt")
En este ejemplo, primero definimos el modelo como antes. Luego, creamos un objeto Saver. Durante el proceso de entrenamiento, cada 100 épocas, guardamos el modelo en un archivo de punto de control.
El ejemplo de código define el modelo, define el saver, ejecuta el grafo de cálculo y guarda el modelo en un archivo de punto de control.
Salida:
La salida del código será una lista de pérdidas, una por cada época. Las pérdidas disminuirán con el tiempo a medida que el modelo aprenda. Después de que el modelo haya terminado de entrenar, el saver guardará el modelo en el archivo de punto de control /tmp/my_model.ckpt. Este archivo se puede utilizar para restaurar el modelo más adelante.
Por ejemplo, la salida del código podría ser:
Epoch: 0 Loss: 10.0
Epoch: 100 Loss: 0.1
Epoch: 200 Loss: 0.01
Epoch: 300 Loss: 0.001
Epoch: 400 Loss: 0.0001
Epoch: 500 Loss: 0.00001
...
Epoch: 900 Loss: 0.00000001
Epoch: 910 Loss: 0.00000001
Epoch: 920 Loss: 0.00000001
...7.3.2 Carga de Modelos
Cargar un modelo es un proceso crucial en el aprendizaje automático. El proceso implica restaurar las variables guardadas desde el archivo de punto de control. Esto permite que el modelo se ponga en uso, por ejemplo, para hacer predicciones sobre nuevos datos.
Dado que el archivo de punto de control contiene toda la información relevante sobre el modelo, es importante asegurarse de que el archivo se guarde y almacene adecuadamente. Además, al cargar un modelo, es importante asegurarse de que la versión del modelo coincida con la versión del software que se está utilizando, para evitar problemas de compatibilidad.
Por lo tanto, es esencial tener un sistema claro y organizado para guardar y cargar modelos de aprendizaje automático, para garantizar su correcto funcionamiento y precisión en aplicaciones del mundo real.
Ejemplo:
Así es cómo se hace:
import tensorflow as tf
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_regression
import numpy as np
# Generate a synthetic regression dataset
X_data, y_data = make_regression(n_samples=1000, n_features=10, noise=0.1, random_state=42)
# Split the dataset into training and validation sets
X_train, X_val, y_train, y_val = train_test_split(X_data, y_data, test_size=0.2, random_state=42)
# Define the number of inputs and outputs
n_inputs = 10
n_outputs = 1
# Build the neural network
X = tf.placeholder(tf.float32, shape=(None, n_inputs), name="X")
hidden = tf.layers.dense(X, n_inputs, name="hidden", activation=tf.nn.relu)
outputs = tf.layers.dense(hidden, n_outputs, name="outputs")
# Define the placeholder for the targets
y = tf.placeholder(tf.float32, shape=(None, n_outputs), name="y")
# Define the loss function
loss = tf.reduce_mean(tf.square(outputs - y)) # MSE
# Define the optimizer and the training operation
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)
training_op = optimizer.minimize(loss)
# Initialize the variables
init = tf.global_variables_initializer()
# Define the saver
saver = tf.train.Saver()
# Run the computation graph
with tf.Session() as sess:
sess.run(init)
for epoch in range(1000):
_, loss_value = sess.run([training_op, loss], feed_dict={X: X_train, y: y_train.reshape(-1, 1)})
if epoch % 100 == 0:
print("Epoch:", epoch, "\tLoss:", loss_value)
save_path = saver.save(sess, "/tmp/my_model.ckpt")
# Restore the model
with tf.Session() as sess:
saver.restore(sess, "/tmp/my_model.ckpt")
# Continue training or use the model
...
En este ejemplo, creamos una nueva sesión y restauramos el modelo desde el archivo de punto de control.
Este código de ejemplo restaura el modelo desde el archivo de punto de control /tmp/my_model.ckpt y luego continúa entrenando o utiliza el modelo.
Salida:
La salida del código será la misma que la salida del código anterior, excepto que el modelo se inicializará con los valores del archivo de punto de control. Esto significa que el modelo continuará entrenando desde donde lo dejó o se puede utilizar directamente sin necesidad de más entrenamiento.
Por ejemplo, la salida del código podría ser:
Epoch: 0 Loss: 10.0
Epoch: 100 Loss: 0.1
Epoch: 200 Loss: 0.01
Epoch: 300 Loss: 0.001
Epoch: 400 Loss: 0.0001
Epoch: 500 Loss: 0.00001
...
Epoch: 900 Loss: 0.00000001
Epoch: 910 Loss: 0.00000001
Epoch: 920 Loss: 0.00000001
...Después de restaurar el modelo desde el archivo de punto de control, podemos continuar el entrenamiento o usar el modelo para hacer predicciones. Aquí tienes cómo hacerlo:
import tensorflow as tf
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_regression
# Generate a synthetic regression dataset
X_data, y_data = make_regression(n_samples=1000, n_features=10, noise=0.1, random_state=42)
# Split the dataset into training and validation sets
X_train, X_val, y_train, y_val = train_test_split(X_data, y_data, test_size=0.2, random_state=42)
# Define the number of inputs and outputs
n_inputs = 10
n_outputs = 1
# Build the neural network
X = tf.placeholder(tf.float32, shape=(None, n_inputs), name="X")
hidden = tf.layers.dense(X, n_inputs, name="hidden", activation=tf.nn.relu)
outputs = tf.layers.dense(hidden, n_outputs, name="outputs")
# Define the placeholder for the targets
y = tf.placeholder(tf.float32, shape=(None, n_outputs), name="y")
# Define the loss function
loss = tf.reduce_mean(tf.square(outputs - y)) # MSE
# Define the optimizer and the training operation
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)
training_op = optimizer.minimize(loss)
# Initialize the variables
init = tf.global_variables_initializer()
# Define the saver
saver = tf.train.Saver()
# Restore the model
with tf.Session() as sess:
saver.restore(sess, "/tmp/my_model.ckpt")
# Continue training the restored model
for epoch in range(1000):
_, loss_value = sess.run([training_op, loss], feed_dict={X: X_train, y: y_train.reshape(-1, 1)})
if epoch % 100 == 0:
print("Epoch:", epoch, "\tLoss:", loss_value)
En este ejemplo, restauramos el modelo y continuamos el proceso de entrenamiento desde donde lo dejamos. La llamada a saver.restore() debe estar antes del bucle for, no dentro de él. Esto se debe a que el salvador necesita cargar los parámetros del modelo en la memoria antes de que el modelo pueda ser utilizado.
Es importante tener en cuenta que el objeto Saver no guarda la estructura del modelo, lo que significa que debes crear el modelo de la misma manera antes de poder restaurarlo. Si deseas guardar también la estructura del modelo, puedes utilizar el formato SavedModel, que es un formato de serialización universal para modelos de TensorFlow.
Aquí tienes cómo guardar un modelo en el formato SavedModel:
import tensorflow as tf
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_regression
# Generate a synthetic regression dataset
X_data, y_data = make_regression(n_samples=1000, n_features=10, noise=0.1, random_state=42)
# Split the dataset into training and validation sets
X_train, X_val, y_train, y_val = train_test_split(X_data, y_data, test_size=0.2, random_state=42)
# Define the number of inputs and outputs
n_inputs = 10
n_outputs = 1 # For regression, typically one output node
# Build the neural network
X = tf.placeholder(tf.float32, shape=(None, n_inputs), name="X")
hidden = tf.layers.dense(X, n_inputs, name="hidden", activation=tf.nn.relu)
outputs = tf.layers.dense(hidden, n_outputs, name="outputs")
# Define the placeholder for the targets
y = tf.placeholder(tf.float32, shape=(None, n_outputs), name="y")
# Define the loss function
loss = tf.reduce_mean(tf.square(outputs - y)) # MSE
# Define the optimizer and the training operation
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)
training_op = optimizer.minimize(loss)
# Initialize the variables
init = tf.global_variables_initializer()
# Run the computation graph
with tf.Session() as sess:
sess.run(init)
for epoch in range(1000):
_, loss_value = sess.run([training_op, loss], feed_dict={X: X_train, y: y_train.reshape(-1, 1)})
if epoch % 100 == 0:
print("Epoch:", epoch, "\tLoss:", loss_value)
# Save the model
inputs = {"X": X}
outputs = {"outputs": outputs}
tf.saved_model.simple_save(sess, "/tmp/my_model", inputs, outputs)
La salida del código será un archivo SavedModel en /tmp/my_model. Este archivo se puede utilizar para restaurar el modelo más adelante.
Y aquí tienes cómo cargar un modelo en el formato SavedModel:
import tensorflow as tf
# Load the saved model
with tf.Session() as sess:
tf.saved_model.loader.load(sess, [tf.saved_model.tag_constants.SERVING], "/tmp/my_model")
# Retrieve the input and output tensors
graph = tf.get_default_graph()
X = graph.get_tensor_by_name("X:0")
outputs = graph.get_tensor_by_name("outputs/BiasAdd:0") # Adjust the tensor name based on your model
# Use the model for inference
# For example, if you have new data X_new, you can feed it to the model and get predictions
X_new = ... # Your new data
predictions = sess.run(outputs, feed_dict={X: X_new})
print("Predictions:", predictions)
# Continue training if needed
# For example, you can define additional training operations and run them
...En estos ejemplos, utilizamos la función tf.saved_model.simple_save para guardar el modelo y la función tf.saved_model.loader.load para cargar el modelo. El formato SavedModel guarda tanto la estructura del modelo como los valores de las variables.
7.3 Guardar y Cargar Modelos en TensorFlow
Después de entrenar un modelo en TensorFlow, es crucial saber cómo guardarlo y cargarlo. Esto no solo le permite reutilizar su modelo en múltiples sesiones, sino que también facilita compartirlo con otros. Además, le permite guardar puntos de control de su modelo durante el entrenamiento, lo que puede ser útil en caso de interrupciones.
Otra ventaja de saber cómo guardar y cargar modelos es que le permite experimentar con diferentes arquitecturas de modelos y explorar diversas hiperparámetros sin tener que entrenar su modelo desde cero cada vez. Además, guardar modelos con diferentes configuraciones también puede servir como una forma de control de versiones, lo que le permite realizar un seguimiento de la evolución de su modelo a lo largo del tiempo y comparar diferentes versiones para ver cuáles funcionan mejor.
7.3.1 Guardar Modelos
TensorFlow proporciona una API simple pero completa para guardar y restaurar un modelo, que es un aspecto crucial de cualquier proyecto de aprendizaje automático. La clase tf.train.Saver es parte integral de esta API, ya que agrega las operaciones necesarias para guardar y restaurar variables desde y hacia puntos de control (checkpoints).
Al almacenar eficientemente las variables del modelo entrenado y sus valores correspondientes, la clase tf.train.Saver permite a los desarrolladores reutilizar y ajustar fácilmente sus modelos sin tener que volver a entrenarlos desde cero cada vez. La clase tf.train.Saver ofrece una serie de métodos de conveniencia que permiten a los desarrolladores ejecutar eficientemente estas operaciones, simplificando aún más el flujo de trabajo de creación e implementación de modelos de aprendizaje automático.
La clase tf.train.Saver es una herramienta esencial en el kit de herramientas del desarrollador de aprendizaje automático, que le permite ahorrar tiempo y recursos mientras construye modelos poderosos y escalables.
Ejemplo:
Aquí tienes un ejemplo de cómo guardar un modelo en TensorFlow:
import tensorflow as tf
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_regression
import numpy as np
# Generate a synthetic regression dataset
X_data, y_data = make_regression(n_samples=1000, n_features=10, noise=0.1, random_state=42)
# Split the dataset into training and validation sets
X_train, X_val, y_train, y_val = train_test_split(X_data, y_data, test_size=0.2, random_state=42)
# Define the number of inputs and outputs
n_inputs = 10
n_outputs = 1
# Build the neural network
X = tf.placeholder(tf.float32, shape=(None, n_inputs), name="X")
hidden = tf.layers.dense(X, n_inputs, name="hidden", activation=tf.nn.relu)
outputs = tf.layers.dense(hidden, n_outputs, name="outputs")
# Define the placeholder for the targets
y = tf.placeholder(tf.float32, shape=(None, n_outputs), name="y")
# Define the loss function
loss = tf.reduce_mean(tf.square(outputs - y)) # MSE
# Define the optimizer and the training operation
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)
training_op = optimizer.minimize(loss)
# Initialize the variables
init = tf.global_variables_initializer()
# Define the saver
saver = tf.train.Saver()
# Run the computation graph
with tf.Session() as sess:
sess.run(init)
for epoch in range(1000):
_, loss_value = sess.run([training_op, loss], feed_dict={X: X_train, y: y_train.reshape(-1, 1)})
if epoch % 100 == 0:
print("Epoch:", epoch, "\tLoss:", loss_value)
save_path = saver.save(sess, "/tmp/my_model.ckpt")
En este ejemplo, primero definimos el modelo como antes. Luego, creamos un objeto Saver. Durante el proceso de entrenamiento, cada 100 épocas, guardamos el modelo en un archivo de punto de control.
El ejemplo de código define el modelo, define el saver, ejecuta el grafo de cálculo y guarda el modelo en un archivo de punto de control.
Salida:
La salida del código será una lista de pérdidas, una por cada época. Las pérdidas disminuirán con el tiempo a medida que el modelo aprenda. Después de que el modelo haya terminado de entrenar, el saver guardará el modelo en el archivo de punto de control /tmp/my_model.ckpt. Este archivo se puede utilizar para restaurar el modelo más adelante.
Por ejemplo, la salida del código podría ser:
Epoch: 0 Loss: 10.0
Epoch: 100 Loss: 0.1
Epoch: 200 Loss: 0.01
Epoch: 300 Loss: 0.001
Epoch: 400 Loss: 0.0001
Epoch: 500 Loss: 0.00001
...
Epoch: 900 Loss: 0.00000001
Epoch: 910 Loss: 0.00000001
Epoch: 920 Loss: 0.00000001
...7.3.2 Carga de Modelos
Cargar un modelo es un proceso crucial en el aprendizaje automático. El proceso implica restaurar las variables guardadas desde el archivo de punto de control. Esto permite que el modelo se ponga en uso, por ejemplo, para hacer predicciones sobre nuevos datos.
Dado que el archivo de punto de control contiene toda la información relevante sobre el modelo, es importante asegurarse de que el archivo se guarde y almacene adecuadamente. Además, al cargar un modelo, es importante asegurarse de que la versión del modelo coincida con la versión del software que se está utilizando, para evitar problemas de compatibilidad.
Por lo tanto, es esencial tener un sistema claro y organizado para guardar y cargar modelos de aprendizaje automático, para garantizar su correcto funcionamiento y precisión en aplicaciones del mundo real.
Ejemplo:
Así es cómo se hace:
import tensorflow as tf
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_regression
import numpy as np
# Generate a synthetic regression dataset
X_data, y_data = make_regression(n_samples=1000, n_features=10, noise=0.1, random_state=42)
# Split the dataset into training and validation sets
X_train, X_val, y_train, y_val = train_test_split(X_data, y_data, test_size=0.2, random_state=42)
# Define the number of inputs and outputs
n_inputs = 10
n_outputs = 1
# Build the neural network
X = tf.placeholder(tf.float32, shape=(None, n_inputs), name="X")
hidden = tf.layers.dense(X, n_inputs, name="hidden", activation=tf.nn.relu)
outputs = tf.layers.dense(hidden, n_outputs, name="outputs")
# Define the placeholder for the targets
y = tf.placeholder(tf.float32, shape=(None, n_outputs), name="y")
# Define the loss function
loss = tf.reduce_mean(tf.square(outputs - y)) # MSE
# Define the optimizer and the training operation
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)
training_op = optimizer.minimize(loss)
# Initialize the variables
init = tf.global_variables_initializer()
# Define the saver
saver = tf.train.Saver()
# Run the computation graph
with tf.Session() as sess:
sess.run(init)
for epoch in range(1000):
_, loss_value = sess.run([training_op, loss], feed_dict={X: X_train, y: y_train.reshape(-1, 1)})
if epoch % 100 == 0:
print("Epoch:", epoch, "\tLoss:", loss_value)
save_path = saver.save(sess, "/tmp/my_model.ckpt")
# Restore the model
with tf.Session() as sess:
saver.restore(sess, "/tmp/my_model.ckpt")
# Continue training or use the model
...
En este ejemplo, creamos una nueva sesión y restauramos el modelo desde el archivo de punto de control.
Este código de ejemplo restaura el modelo desde el archivo de punto de control /tmp/my_model.ckpt y luego continúa entrenando o utiliza el modelo.
Salida:
La salida del código será la misma que la salida del código anterior, excepto que el modelo se inicializará con los valores del archivo de punto de control. Esto significa que el modelo continuará entrenando desde donde lo dejó o se puede utilizar directamente sin necesidad de más entrenamiento.
Por ejemplo, la salida del código podría ser:
Epoch: 0 Loss: 10.0
Epoch: 100 Loss: 0.1
Epoch: 200 Loss: 0.01
Epoch: 300 Loss: 0.001
Epoch: 400 Loss: 0.0001
Epoch: 500 Loss: 0.00001
...
Epoch: 900 Loss: 0.00000001
Epoch: 910 Loss: 0.00000001
Epoch: 920 Loss: 0.00000001
...Después de restaurar el modelo desde el archivo de punto de control, podemos continuar el entrenamiento o usar el modelo para hacer predicciones. Aquí tienes cómo hacerlo:
import tensorflow as tf
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_regression
# Generate a synthetic regression dataset
X_data, y_data = make_regression(n_samples=1000, n_features=10, noise=0.1, random_state=42)
# Split the dataset into training and validation sets
X_train, X_val, y_train, y_val = train_test_split(X_data, y_data, test_size=0.2, random_state=42)
# Define the number of inputs and outputs
n_inputs = 10
n_outputs = 1
# Build the neural network
X = tf.placeholder(tf.float32, shape=(None, n_inputs), name="X")
hidden = tf.layers.dense(X, n_inputs, name="hidden", activation=tf.nn.relu)
outputs = tf.layers.dense(hidden, n_outputs, name="outputs")
# Define the placeholder for the targets
y = tf.placeholder(tf.float32, shape=(None, n_outputs), name="y")
# Define the loss function
loss = tf.reduce_mean(tf.square(outputs - y)) # MSE
# Define the optimizer and the training operation
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)
training_op = optimizer.minimize(loss)
# Initialize the variables
init = tf.global_variables_initializer()
# Define the saver
saver = tf.train.Saver()
# Restore the model
with tf.Session() as sess:
saver.restore(sess, "/tmp/my_model.ckpt")
# Continue training the restored model
for epoch in range(1000):
_, loss_value = sess.run([training_op, loss], feed_dict={X: X_train, y: y_train.reshape(-1, 1)})
if epoch % 100 == 0:
print("Epoch:", epoch, "\tLoss:", loss_value)
En este ejemplo, restauramos el modelo y continuamos el proceso de entrenamiento desde donde lo dejamos. La llamada a saver.restore() debe estar antes del bucle for, no dentro de él. Esto se debe a que el salvador necesita cargar los parámetros del modelo en la memoria antes de que el modelo pueda ser utilizado.
Es importante tener en cuenta que el objeto Saver no guarda la estructura del modelo, lo que significa que debes crear el modelo de la misma manera antes de poder restaurarlo. Si deseas guardar también la estructura del modelo, puedes utilizar el formato SavedModel, que es un formato de serialización universal para modelos de TensorFlow.
Aquí tienes cómo guardar un modelo en el formato SavedModel:
import tensorflow as tf
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_regression
# Generate a synthetic regression dataset
X_data, y_data = make_regression(n_samples=1000, n_features=10, noise=0.1, random_state=42)
# Split the dataset into training and validation sets
X_train, X_val, y_train, y_val = train_test_split(X_data, y_data, test_size=0.2, random_state=42)
# Define the number of inputs and outputs
n_inputs = 10
n_outputs = 1 # For regression, typically one output node
# Build the neural network
X = tf.placeholder(tf.float32, shape=(None, n_inputs), name="X")
hidden = tf.layers.dense(X, n_inputs, name="hidden", activation=tf.nn.relu)
outputs = tf.layers.dense(hidden, n_outputs, name="outputs")
# Define the placeholder for the targets
y = tf.placeholder(tf.float32, shape=(None, n_outputs), name="y")
# Define the loss function
loss = tf.reduce_mean(tf.square(outputs - y)) # MSE
# Define the optimizer and the training operation
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)
training_op = optimizer.minimize(loss)
# Initialize the variables
init = tf.global_variables_initializer()
# Run the computation graph
with tf.Session() as sess:
sess.run(init)
for epoch in range(1000):
_, loss_value = sess.run([training_op, loss], feed_dict={X: X_train, y: y_train.reshape(-1, 1)})
if epoch % 100 == 0:
print("Epoch:", epoch, "\tLoss:", loss_value)
# Save the model
inputs = {"X": X}
outputs = {"outputs": outputs}
tf.saved_model.simple_save(sess, "/tmp/my_model", inputs, outputs)
La salida del código será un archivo SavedModel en /tmp/my_model. Este archivo se puede utilizar para restaurar el modelo más adelante.
Y aquí tienes cómo cargar un modelo en el formato SavedModel:
import tensorflow as tf
# Load the saved model
with tf.Session() as sess:
tf.saved_model.loader.load(sess, [tf.saved_model.tag_constants.SERVING], "/tmp/my_model")
# Retrieve the input and output tensors
graph = tf.get_default_graph()
X = graph.get_tensor_by_name("X:0")
outputs = graph.get_tensor_by_name("outputs/BiasAdd:0") # Adjust the tensor name based on your model
# Use the model for inference
# For example, if you have new data X_new, you can feed it to the model and get predictions
X_new = ... # Your new data
predictions = sess.run(outputs, feed_dict={X: X_new})
print("Predictions:", predictions)
# Continue training if needed
# For example, you can define additional training operations and run them
...En estos ejemplos, utilizamos la función tf.saved_model.simple_save para guardar el modelo y la función tf.saved_model.loader.load para cargar el modelo. El formato SavedModel guarda tanto la estructura del modelo como los valores de las variables.
7.3 Guardar y Cargar Modelos en TensorFlow
Después de entrenar un modelo en TensorFlow, es crucial saber cómo guardarlo y cargarlo. Esto no solo le permite reutilizar su modelo en múltiples sesiones, sino que también facilita compartirlo con otros. Además, le permite guardar puntos de control de su modelo durante el entrenamiento, lo que puede ser útil en caso de interrupciones.
Otra ventaja de saber cómo guardar y cargar modelos es que le permite experimentar con diferentes arquitecturas de modelos y explorar diversas hiperparámetros sin tener que entrenar su modelo desde cero cada vez. Además, guardar modelos con diferentes configuraciones también puede servir como una forma de control de versiones, lo que le permite realizar un seguimiento de la evolución de su modelo a lo largo del tiempo y comparar diferentes versiones para ver cuáles funcionan mejor.
7.3.1 Guardar Modelos
TensorFlow proporciona una API simple pero completa para guardar y restaurar un modelo, que es un aspecto crucial de cualquier proyecto de aprendizaje automático. La clase tf.train.Saver es parte integral de esta API, ya que agrega las operaciones necesarias para guardar y restaurar variables desde y hacia puntos de control (checkpoints).
Al almacenar eficientemente las variables del modelo entrenado y sus valores correspondientes, la clase tf.train.Saver permite a los desarrolladores reutilizar y ajustar fácilmente sus modelos sin tener que volver a entrenarlos desde cero cada vez. La clase tf.train.Saver ofrece una serie de métodos de conveniencia que permiten a los desarrolladores ejecutar eficientemente estas operaciones, simplificando aún más el flujo de trabajo de creación e implementación de modelos de aprendizaje automático.
La clase tf.train.Saver es una herramienta esencial en el kit de herramientas del desarrollador de aprendizaje automático, que le permite ahorrar tiempo y recursos mientras construye modelos poderosos y escalables.
Ejemplo:
Aquí tienes un ejemplo de cómo guardar un modelo en TensorFlow:
import tensorflow as tf
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_regression
import numpy as np
# Generate a synthetic regression dataset
X_data, y_data = make_regression(n_samples=1000, n_features=10, noise=0.1, random_state=42)
# Split the dataset into training and validation sets
X_train, X_val, y_train, y_val = train_test_split(X_data, y_data, test_size=0.2, random_state=42)
# Define the number of inputs and outputs
n_inputs = 10
n_outputs = 1
# Build the neural network
X = tf.placeholder(tf.float32, shape=(None, n_inputs), name="X")
hidden = tf.layers.dense(X, n_inputs, name="hidden", activation=tf.nn.relu)
outputs = tf.layers.dense(hidden, n_outputs, name="outputs")
# Define the placeholder for the targets
y = tf.placeholder(tf.float32, shape=(None, n_outputs), name="y")
# Define the loss function
loss = tf.reduce_mean(tf.square(outputs - y)) # MSE
# Define the optimizer and the training operation
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)
training_op = optimizer.minimize(loss)
# Initialize the variables
init = tf.global_variables_initializer()
# Define the saver
saver = tf.train.Saver()
# Run the computation graph
with tf.Session() as sess:
sess.run(init)
for epoch in range(1000):
_, loss_value = sess.run([training_op, loss], feed_dict={X: X_train, y: y_train.reshape(-1, 1)})
if epoch % 100 == 0:
print("Epoch:", epoch, "\tLoss:", loss_value)
save_path = saver.save(sess, "/tmp/my_model.ckpt")
En este ejemplo, primero definimos el modelo como antes. Luego, creamos un objeto Saver. Durante el proceso de entrenamiento, cada 100 épocas, guardamos el modelo en un archivo de punto de control.
El ejemplo de código define el modelo, define el saver, ejecuta el grafo de cálculo y guarda el modelo en un archivo de punto de control.
Salida:
La salida del código será una lista de pérdidas, una por cada época. Las pérdidas disminuirán con el tiempo a medida que el modelo aprenda. Después de que el modelo haya terminado de entrenar, el saver guardará el modelo en el archivo de punto de control /tmp/my_model.ckpt. Este archivo se puede utilizar para restaurar el modelo más adelante.
Por ejemplo, la salida del código podría ser:
Epoch: 0 Loss: 10.0
Epoch: 100 Loss: 0.1
Epoch: 200 Loss: 0.01
Epoch: 300 Loss: 0.001
Epoch: 400 Loss: 0.0001
Epoch: 500 Loss: 0.00001
...
Epoch: 900 Loss: 0.00000001
Epoch: 910 Loss: 0.00000001
Epoch: 920 Loss: 0.00000001
...7.3.2 Carga de Modelos
Cargar un modelo es un proceso crucial en el aprendizaje automático. El proceso implica restaurar las variables guardadas desde el archivo de punto de control. Esto permite que el modelo se ponga en uso, por ejemplo, para hacer predicciones sobre nuevos datos.
Dado que el archivo de punto de control contiene toda la información relevante sobre el modelo, es importante asegurarse de que el archivo se guarde y almacene adecuadamente. Además, al cargar un modelo, es importante asegurarse de que la versión del modelo coincida con la versión del software que se está utilizando, para evitar problemas de compatibilidad.
Por lo tanto, es esencial tener un sistema claro y organizado para guardar y cargar modelos de aprendizaje automático, para garantizar su correcto funcionamiento y precisión en aplicaciones del mundo real.
Ejemplo:
Así es cómo se hace:
import tensorflow as tf
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_regression
import numpy as np
# Generate a synthetic regression dataset
X_data, y_data = make_regression(n_samples=1000, n_features=10, noise=0.1, random_state=42)
# Split the dataset into training and validation sets
X_train, X_val, y_train, y_val = train_test_split(X_data, y_data, test_size=0.2, random_state=42)
# Define the number of inputs and outputs
n_inputs = 10
n_outputs = 1
# Build the neural network
X = tf.placeholder(tf.float32, shape=(None, n_inputs), name="X")
hidden = tf.layers.dense(X, n_inputs, name="hidden", activation=tf.nn.relu)
outputs = tf.layers.dense(hidden, n_outputs, name="outputs")
# Define the placeholder for the targets
y = tf.placeholder(tf.float32, shape=(None, n_outputs), name="y")
# Define the loss function
loss = tf.reduce_mean(tf.square(outputs - y)) # MSE
# Define the optimizer and the training operation
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)
training_op = optimizer.minimize(loss)
# Initialize the variables
init = tf.global_variables_initializer()
# Define the saver
saver = tf.train.Saver()
# Run the computation graph
with tf.Session() as sess:
sess.run(init)
for epoch in range(1000):
_, loss_value = sess.run([training_op, loss], feed_dict={X: X_train, y: y_train.reshape(-1, 1)})
if epoch % 100 == 0:
print("Epoch:", epoch, "\tLoss:", loss_value)
save_path = saver.save(sess, "/tmp/my_model.ckpt")
# Restore the model
with tf.Session() as sess:
saver.restore(sess, "/tmp/my_model.ckpt")
# Continue training or use the model
...
En este ejemplo, creamos una nueva sesión y restauramos el modelo desde el archivo de punto de control.
Este código de ejemplo restaura el modelo desde el archivo de punto de control /tmp/my_model.ckpt y luego continúa entrenando o utiliza el modelo.
Salida:
La salida del código será la misma que la salida del código anterior, excepto que el modelo se inicializará con los valores del archivo de punto de control. Esto significa que el modelo continuará entrenando desde donde lo dejó o se puede utilizar directamente sin necesidad de más entrenamiento.
Por ejemplo, la salida del código podría ser:
Epoch: 0 Loss: 10.0
Epoch: 100 Loss: 0.1
Epoch: 200 Loss: 0.01
Epoch: 300 Loss: 0.001
Epoch: 400 Loss: 0.0001
Epoch: 500 Loss: 0.00001
...
Epoch: 900 Loss: 0.00000001
Epoch: 910 Loss: 0.00000001
Epoch: 920 Loss: 0.00000001
...Después de restaurar el modelo desde el archivo de punto de control, podemos continuar el entrenamiento o usar el modelo para hacer predicciones. Aquí tienes cómo hacerlo:
import tensorflow as tf
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_regression
# Generate a synthetic regression dataset
X_data, y_data = make_regression(n_samples=1000, n_features=10, noise=0.1, random_state=42)
# Split the dataset into training and validation sets
X_train, X_val, y_train, y_val = train_test_split(X_data, y_data, test_size=0.2, random_state=42)
# Define the number of inputs and outputs
n_inputs = 10
n_outputs = 1
# Build the neural network
X = tf.placeholder(tf.float32, shape=(None, n_inputs), name="X")
hidden = tf.layers.dense(X, n_inputs, name="hidden", activation=tf.nn.relu)
outputs = tf.layers.dense(hidden, n_outputs, name="outputs")
# Define the placeholder for the targets
y = tf.placeholder(tf.float32, shape=(None, n_outputs), name="y")
# Define the loss function
loss = tf.reduce_mean(tf.square(outputs - y)) # MSE
# Define the optimizer and the training operation
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)
training_op = optimizer.minimize(loss)
# Initialize the variables
init = tf.global_variables_initializer()
# Define the saver
saver = tf.train.Saver()
# Restore the model
with tf.Session() as sess:
saver.restore(sess, "/tmp/my_model.ckpt")
# Continue training the restored model
for epoch in range(1000):
_, loss_value = sess.run([training_op, loss], feed_dict={X: X_train, y: y_train.reshape(-1, 1)})
if epoch % 100 == 0:
print("Epoch:", epoch, "\tLoss:", loss_value)
En este ejemplo, restauramos el modelo y continuamos el proceso de entrenamiento desde donde lo dejamos. La llamada a saver.restore() debe estar antes del bucle for, no dentro de él. Esto se debe a que el salvador necesita cargar los parámetros del modelo en la memoria antes de que el modelo pueda ser utilizado.
Es importante tener en cuenta que el objeto Saver no guarda la estructura del modelo, lo que significa que debes crear el modelo de la misma manera antes de poder restaurarlo. Si deseas guardar también la estructura del modelo, puedes utilizar el formato SavedModel, que es un formato de serialización universal para modelos de TensorFlow.
Aquí tienes cómo guardar un modelo en el formato SavedModel:
import tensorflow as tf
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_regression
# Generate a synthetic regression dataset
X_data, y_data = make_regression(n_samples=1000, n_features=10, noise=0.1, random_state=42)
# Split the dataset into training and validation sets
X_train, X_val, y_train, y_val = train_test_split(X_data, y_data, test_size=0.2, random_state=42)
# Define the number of inputs and outputs
n_inputs = 10
n_outputs = 1 # For regression, typically one output node
# Build the neural network
X = tf.placeholder(tf.float32, shape=(None, n_inputs), name="X")
hidden = tf.layers.dense(X, n_inputs, name="hidden", activation=tf.nn.relu)
outputs = tf.layers.dense(hidden, n_outputs, name="outputs")
# Define the placeholder for the targets
y = tf.placeholder(tf.float32, shape=(None, n_outputs), name="y")
# Define the loss function
loss = tf.reduce_mean(tf.square(outputs - y)) # MSE
# Define the optimizer and the training operation
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)
training_op = optimizer.minimize(loss)
# Initialize the variables
init = tf.global_variables_initializer()
# Run the computation graph
with tf.Session() as sess:
sess.run(init)
for epoch in range(1000):
_, loss_value = sess.run([training_op, loss], feed_dict={X: X_train, y: y_train.reshape(-1, 1)})
if epoch % 100 == 0:
print("Epoch:", epoch, "\tLoss:", loss_value)
# Save the model
inputs = {"X": X}
outputs = {"outputs": outputs}
tf.saved_model.simple_save(sess, "/tmp/my_model", inputs, outputs)
La salida del código será un archivo SavedModel en /tmp/my_model. Este archivo se puede utilizar para restaurar el modelo más adelante.
Y aquí tienes cómo cargar un modelo en el formato SavedModel:
import tensorflow as tf
# Load the saved model
with tf.Session() as sess:
tf.saved_model.loader.load(sess, [tf.saved_model.tag_constants.SERVING], "/tmp/my_model")
# Retrieve the input and output tensors
graph = tf.get_default_graph()
X = graph.get_tensor_by_name("X:0")
outputs = graph.get_tensor_by_name("outputs/BiasAdd:0") # Adjust the tensor name based on your model
# Use the model for inference
# For example, if you have new data X_new, you can feed it to the model and get predictions
X_new = ... # Your new data
predictions = sess.run(outputs, feed_dict={X: X_new})
print("Predictions:", predictions)
# Continue training if needed
# For example, you can define additional training operations and run them
...En estos ejemplos, utilizamos la función tf.saved_model.simple_save para guardar el modelo y la función tf.saved_model.loader.load para cargar el modelo. El formato SavedModel guarda tanto la estructura del modelo como los valores de las variables.
7.3 Guardar y Cargar Modelos en TensorFlow
Después de entrenar un modelo en TensorFlow, es crucial saber cómo guardarlo y cargarlo. Esto no solo le permite reutilizar su modelo en múltiples sesiones, sino que también facilita compartirlo con otros. Además, le permite guardar puntos de control de su modelo durante el entrenamiento, lo que puede ser útil en caso de interrupciones.
Otra ventaja de saber cómo guardar y cargar modelos es que le permite experimentar con diferentes arquitecturas de modelos y explorar diversas hiperparámetros sin tener que entrenar su modelo desde cero cada vez. Además, guardar modelos con diferentes configuraciones también puede servir como una forma de control de versiones, lo que le permite realizar un seguimiento de la evolución de su modelo a lo largo del tiempo y comparar diferentes versiones para ver cuáles funcionan mejor.
7.3.1 Guardar Modelos
TensorFlow proporciona una API simple pero completa para guardar y restaurar un modelo, que es un aspecto crucial de cualquier proyecto de aprendizaje automático. La clase tf.train.Saver es parte integral de esta API, ya que agrega las operaciones necesarias para guardar y restaurar variables desde y hacia puntos de control (checkpoints).
Al almacenar eficientemente las variables del modelo entrenado y sus valores correspondientes, la clase tf.train.Saver permite a los desarrolladores reutilizar y ajustar fácilmente sus modelos sin tener que volver a entrenarlos desde cero cada vez. La clase tf.train.Saver ofrece una serie de métodos de conveniencia que permiten a los desarrolladores ejecutar eficientemente estas operaciones, simplificando aún más el flujo de trabajo de creación e implementación de modelos de aprendizaje automático.
La clase tf.train.Saver es una herramienta esencial en el kit de herramientas del desarrollador de aprendizaje automático, que le permite ahorrar tiempo y recursos mientras construye modelos poderosos y escalables.
Ejemplo:
Aquí tienes un ejemplo de cómo guardar un modelo en TensorFlow:
import tensorflow as tf
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_regression
import numpy as np
# Generate a synthetic regression dataset
X_data, y_data = make_regression(n_samples=1000, n_features=10, noise=0.1, random_state=42)
# Split the dataset into training and validation sets
X_train, X_val, y_train, y_val = train_test_split(X_data, y_data, test_size=0.2, random_state=42)
# Define the number of inputs and outputs
n_inputs = 10
n_outputs = 1
# Build the neural network
X = tf.placeholder(tf.float32, shape=(None, n_inputs), name="X")
hidden = tf.layers.dense(X, n_inputs, name="hidden", activation=tf.nn.relu)
outputs = tf.layers.dense(hidden, n_outputs, name="outputs")
# Define the placeholder for the targets
y = tf.placeholder(tf.float32, shape=(None, n_outputs), name="y")
# Define the loss function
loss = tf.reduce_mean(tf.square(outputs - y)) # MSE
# Define the optimizer and the training operation
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)
training_op = optimizer.minimize(loss)
# Initialize the variables
init = tf.global_variables_initializer()
# Define the saver
saver = tf.train.Saver()
# Run the computation graph
with tf.Session() as sess:
sess.run(init)
for epoch in range(1000):
_, loss_value = sess.run([training_op, loss], feed_dict={X: X_train, y: y_train.reshape(-1, 1)})
if epoch % 100 == 0:
print("Epoch:", epoch, "\tLoss:", loss_value)
save_path = saver.save(sess, "/tmp/my_model.ckpt")
En este ejemplo, primero definimos el modelo como antes. Luego, creamos un objeto Saver. Durante el proceso de entrenamiento, cada 100 épocas, guardamos el modelo en un archivo de punto de control.
El ejemplo de código define el modelo, define el saver, ejecuta el grafo de cálculo y guarda el modelo en un archivo de punto de control.
Salida:
La salida del código será una lista de pérdidas, una por cada época. Las pérdidas disminuirán con el tiempo a medida que el modelo aprenda. Después de que el modelo haya terminado de entrenar, el saver guardará el modelo en el archivo de punto de control /tmp/my_model.ckpt. Este archivo se puede utilizar para restaurar el modelo más adelante.
Por ejemplo, la salida del código podría ser:
Epoch: 0 Loss: 10.0
Epoch: 100 Loss: 0.1
Epoch: 200 Loss: 0.01
Epoch: 300 Loss: 0.001
Epoch: 400 Loss: 0.0001
Epoch: 500 Loss: 0.00001
...
Epoch: 900 Loss: 0.00000001
Epoch: 910 Loss: 0.00000001
Epoch: 920 Loss: 0.00000001
...7.3.2 Carga de Modelos
Cargar un modelo es un proceso crucial en el aprendizaje automático. El proceso implica restaurar las variables guardadas desde el archivo de punto de control. Esto permite que el modelo se ponga en uso, por ejemplo, para hacer predicciones sobre nuevos datos.
Dado que el archivo de punto de control contiene toda la información relevante sobre el modelo, es importante asegurarse de que el archivo se guarde y almacene adecuadamente. Además, al cargar un modelo, es importante asegurarse de que la versión del modelo coincida con la versión del software que se está utilizando, para evitar problemas de compatibilidad.
Por lo tanto, es esencial tener un sistema claro y organizado para guardar y cargar modelos de aprendizaje automático, para garantizar su correcto funcionamiento y precisión en aplicaciones del mundo real.
Ejemplo:
Así es cómo se hace:
import tensorflow as tf
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_regression
import numpy as np
# Generate a synthetic regression dataset
X_data, y_data = make_regression(n_samples=1000, n_features=10, noise=0.1, random_state=42)
# Split the dataset into training and validation sets
X_train, X_val, y_train, y_val = train_test_split(X_data, y_data, test_size=0.2, random_state=42)
# Define the number of inputs and outputs
n_inputs = 10
n_outputs = 1
# Build the neural network
X = tf.placeholder(tf.float32, shape=(None, n_inputs), name="X")
hidden = tf.layers.dense(X, n_inputs, name="hidden", activation=tf.nn.relu)
outputs = tf.layers.dense(hidden, n_outputs, name="outputs")
# Define the placeholder for the targets
y = tf.placeholder(tf.float32, shape=(None, n_outputs), name="y")
# Define the loss function
loss = tf.reduce_mean(tf.square(outputs - y)) # MSE
# Define the optimizer and the training operation
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)
training_op = optimizer.minimize(loss)
# Initialize the variables
init = tf.global_variables_initializer()
# Define the saver
saver = tf.train.Saver()
# Run the computation graph
with tf.Session() as sess:
sess.run(init)
for epoch in range(1000):
_, loss_value = sess.run([training_op, loss], feed_dict={X: X_train, y: y_train.reshape(-1, 1)})
if epoch % 100 == 0:
print("Epoch:", epoch, "\tLoss:", loss_value)
save_path = saver.save(sess, "/tmp/my_model.ckpt")
# Restore the model
with tf.Session() as sess:
saver.restore(sess, "/tmp/my_model.ckpt")
# Continue training or use the model
...
En este ejemplo, creamos una nueva sesión y restauramos el modelo desde el archivo de punto de control.
Este código de ejemplo restaura el modelo desde el archivo de punto de control /tmp/my_model.ckpt y luego continúa entrenando o utiliza el modelo.
Salida:
La salida del código será la misma que la salida del código anterior, excepto que el modelo se inicializará con los valores del archivo de punto de control. Esto significa que el modelo continuará entrenando desde donde lo dejó o se puede utilizar directamente sin necesidad de más entrenamiento.
Por ejemplo, la salida del código podría ser:
Epoch: 0 Loss: 10.0
Epoch: 100 Loss: 0.1
Epoch: 200 Loss: 0.01
Epoch: 300 Loss: 0.001
Epoch: 400 Loss: 0.0001
Epoch: 500 Loss: 0.00001
...
Epoch: 900 Loss: 0.00000001
Epoch: 910 Loss: 0.00000001
Epoch: 920 Loss: 0.00000001
...Después de restaurar el modelo desde el archivo de punto de control, podemos continuar el entrenamiento o usar el modelo para hacer predicciones. Aquí tienes cómo hacerlo:
import tensorflow as tf
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_regression
# Generate a synthetic regression dataset
X_data, y_data = make_regression(n_samples=1000, n_features=10, noise=0.1, random_state=42)
# Split the dataset into training and validation sets
X_train, X_val, y_train, y_val = train_test_split(X_data, y_data, test_size=0.2, random_state=42)
# Define the number of inputs and outputs
n_inputs = 10
n_outputs = 1
# Build the neural network
X = tf.placeholder(tf.float32, shape=(None, n_inputs), name="X")
hidden = tf.layers.dense(X, n_inputs, name="hidden", activation=tf.nn.relu)
outputs = tf.layers.dense(hidden, n_outputs, name="outputs")
# Define the placeholder for the targets
y = tf.placeholder(tf.float32, shape=(None, n_outputs), name="y")
# Define the loss function
loss = tf.reduce_mean(tf.square(outputs - y)) # MSE
# Define the optimizer and the training operation
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)
training_op = optimizer.minimize(loss)
# Initialize the variables
init = tf.global_variables_initializer()
# Define the saver
saver = tf.train.Saver()
# Restore the model
with tf.Session() as sess:
saver.restore(sess, "/tmp/my_model.ckpt")
# Continue training the restored model
for epoch in range(1000):
_, loss_value = sess.run([training_op, loss], feed_dict={X: X_train, y: y_train.reshape(-1, 1)})
if epoch % 100 == 0:
print("Epoch:", epoch, "\tLoss:", loss_value)
En este ejemplo, restauramos el modelo y continuamos el proceso de entrenamiento desde donde lo dejamos. La llamada a saver.restore() debe estar antes del bucle for, no dentro de él. Esto se debe a que el salvador necesita cargar los parámetros del modelo en la memoria antes de que el modelo pueda ser utilizado.
Es importante tener en cuenta que el objeto Saver no guarda la estructura del modelo, lo que significa que debes crear el modelo de la misma manera antes de poder restaurarlo. Si deseas guardar también la estructura del modelo, puedes utilizar el formato SavedModel, que es un formato de serialización universal para modelos de TensorFlow.
Aquí tienes cómo guardar un modelo en el formato SavedModel:
import tensorflow as tf
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_regression
# Generate a synthetic regression dataset
X_data, y_data = make_regression(n_samples=1000, n_features=10, noise=0.1, random_state=42)
# Split the dataset into training and validation sets
X_train, X_val, y_train, y_val = train_test_split(X_data, y_data, test_size=0.2, random_state=42)
# Define the number of inputs and outputs
n_inputs = 10
n_outputs = 1 # For regression, typically one output node
# Build the neural network
X = tf.placeholder(tf.float32, shape=(None, n_inputs), name="X")
hidden = tf.layers.dense(X, n_inputs, name="hidden", activation=tf.nn.relu)
outputs = tf.layers.dense(hidden, n_outputs, name="outputs")
# Define the placeholder for the targets
y = tf.placeholder(tf.float32, shape=(None, n_outputs), name="y")
# Define the loss function
loss = tf.reduce_mean(tf.square(outputs - y)) # MSE
# Define the optimizer and the training operation
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)
training_op = optimizer.minimize(loss)
# Initialize the variables
init = tf.global_variables_initializer()
# Run the computation graph
with tf.Session() as sess:
sess.run(init)
for epoch in range(1000):
_, loss_value = sess.run([training_op, loss], feed_dict={X: X_train, y: y_train.reshape(-1, 1)})
if epoch % 100 == 0:
print("Epoch:", epoch, "\tLoss:", loss_value)
# Save the model
inputs = {"X": X}
outputs = {"outputs": outputs}
tf.saved_model.simple_save(sess, "/tmp/my_model", inputs, outputs)
La salida del código será un archivo SavedModel en /tmp/my_model. Este archivo se puede utilizar para restaurar el modelo más adelante.
Y aquí tienes cómo cargar un modelo en el formato SavedModel:
import tensorflow as tf
# Load the saved model
with tf.Session() as sess:
tf.saved_model.loader.load(sess, [tf.saved_model.tag_constants.SERVING], "/tmp/my_model")
# Retrieve the input and output tensors
graph = tf.get_default_graph()
X = graph.get_tensor_by_name("X:0")
outputs = graph.get_tensor_by_name("outputs/BiasAdd:0") # Adjust the tensor name based on your model
# Use the model for inference
# For example, if you have new data X_new, you can feed it to the model and get predictions
X_new = ... # Your new data
predictions = sess.run(outputs, feed_dict={X: X_new})
print("Predictions:", predictions)
# Continue training if needed
# For example, you can define additional training operations and run them
...En estos ejemplos, utilizamos la función tf.saved_model.simple_save para guardar el modelo y la función tf.saved_model.loader.load para cargar el modelo. El formato SavedModel guarda tanto la estructura del modelo como los valores de las variables.