Content overview 
 
 
 
 
 
 
 
 Instalación Módulos de TensorFlow Módulos de construcción A la espera de crear variables Ahorrar pesos Funciones de ahorro Creación de un modelo salvavidas Para realizar el aprendizaje automático en TensorFlow, es probable que necesite definir, guardar y restaurar un modelo. Un modelo es, de forma abstracta: 
 
 
 Una función que calcula algo en los tensores (un paso adelante) Algunas variables que se pueden actualizar en respuesta a la formación En esta guía, irás por debajo de la superficie de Keras para ver cómo se definen los modelos de TensorFlow. Instalación import tensorflow as tf
import keras
from datetime import datetime

%load_ext tensorboard
 2023-10-18 01:21:05.536666: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered
2023-10-18 01:21:05.536712: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered
2023-10-18 01:21:05.536766: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered
 Módulos de TensorFlow La mayoría de los modelos están hechos de capas. Las capas son funciones con una estructura matemática conocida que se pueden reutilizar y tienen variables entrenables. En TensorFlow, la mayoría de las implementaciones de nivel alto de capas y modelos, como Keras o , están construidos en la misma clase fundacional: . Sonido tf.Module Módulos de construcción He aquí un ejemplo de una simple que actúa sobre un tensor escalar: tf.Module class SimpleModule(tf.Module):
  def __init__(self, name=None):
    super().__init__(name=name)
    self.a_variable = tf.Variable(5.0, name="train_me")
    self.non_trainable_variable = tf.Variable(5.0, trainable=False, name="do_not_train_me")
  def __call__(self, x):
    return self.a_variable * x + self.non_trainable_variable

simple_module = SimpleModule(name="simple")

simple_module(tf.constant(5.0))
 2023-10-18 01:21:08.181350: W tensorflow/core/common_runtime/gpu/gpu_device.cc:2211] Cannot dlopen some GPU libraries. Please make sure the missing libraries mentioned above are installed properly if you would like to use GPU. Follow the guide at https://www.tensorflow.org/install/gpu for how to download and setup the required libraries for your platform.
Skipping registering GPU devices...
<tf.Tensor: shape=(), dtype=float32, numpy=30.0>
 Los módulos y, por extensión, las capas son terminología de aprendizaje profundo para "objetos": tienen un estado interno y métodos que utilizan ese estado. No hay nada de especial en Aparte de actuar como un Puede invocar sus modelos con cualquier función que desee. __call__ Python llamado Puede ajustar la capacidad de entrenamiento de las variables por cualquier razón, incluyendo la congelación de capas y variables durante el ajuste fino. 
 
 Nota: tf.Module es la clase base tanto para tf.keras.layers.Layer como para tf.keras.Model, por lo que todo lo que encuentras aquí también se aplica a Keras. Por razones de compatibilidad histórica, las capas de Keras no recogen variables de módulos, por lo que tus modelos deben usar sólo módulos o solo capas de Keras. Sin embargo, los métodos que se muestran a continuación para inspeccionar las variables son los mismos en ambos casos.   Es la clase básica para ambos y Por razones de compatibilidad histórica, las capas de Keras no recogen variables de módulos, por lo que sus modelos deben utilizar sólo módulos o sólo capas de Keras. Note: tf.Module tf.keras.layers.Layer tf.keras.Model por la subclassificación cualquiera o las instancias asignadas a las propiedades de este objeto se recopilan automáticamente. Esto le permite guardar y cargar variables, y también crear colecciones de de s. tf.Module tf.Variable tf.Module tf.Module # All trainable variables
print("trainable variables:", simple_module.trainable_variables)
# Every variable
print("all variables:", simple_module.variables)
 trainable variables: (<tf.Variable 'train_me:0' shape=() dtype=float32, numpy=5.0>,)
all variables: (<tf.Variable 'train_me:0' shape=() dtype=float32, numpy=5.0>, <tf.Variable 'do_not_train_me:0' shape=() dtype=float32, numpy=5.0>)
 Este es un ejemplo de un modelo de capa lineal de dos capas hecho de módulos. Primero una capa densa (lineal): class Dense(tf.Module):
  def __init__(self, in_features, out_features, name=None):
    super().__init__(name=name)
    self.w = tf.Variable(
      tf.random.normal([in_features, out_features]), name='w')
    self.b = tf.Variable(tf.zeros([out_features]), name='b')
  def __call__(self, x):
    y = tf.matmul(x, self.w) + self.b
    return tf.nn.relu(y)
 Y luego el modelo completo, que hace dos instancias de capa y las aplica: class SequentialModule(tf.Module):
  def __init__(self, name=None):
    super().__init__(name=name)

    self.dense_1 = Dense(in_features=3, out_features=3)
    self.dense_2 = Dense(in_features=3, out_features=2)

  def __call__(self, x):
    x = self.dense_1(x)
    return self.dense_2(x)

# You have made a model!
my_model = SequentialModule(name="the_model")

# Call it, with random results
print("Model results:", my_model(tf.constant([[2.0, 2.0, 2.0]])))
 Model results: tf.Tensor([[0.       3.415034]], shape=(1, 2), dtype=float32)
 las instancias recopilarán automáticamente, recursivamente, cualquier o instantes asignados a ella. Esto le permite gestionar colecciones de con una sola instancia de modelo, y guardar y cargar modelos enteros. tf.Module tf.Variable tf.Module tf.Module print("Submodules:", my_model.submodules)
 Submodules: (<__main__.Dense object at 0x7f7931aea250>, <__main__.Dense object at 0x7f77ed5b8a00>)
 for var in my_model.variables:
  print(var, "\n")
 <tf.Variable 'b:0' shape=(3,) dtype=float32, numpy=array([0., 0., 0.], dtype=float32)> 

<tf.Variable 'w:0' shape=(3, 3) dtype=float32, numpy=
array([[-2.8161757, -2.6065955,  1.9061812],
       [-0.9430401, -0.4624743, -0.4531979],
       [-1.3428234,  0.7062293,  0.7874674]], dtype=float32)> 

<tf.Variable 'b:0' shape=(2,) dtype=float32, numpy=array([0., 0.], dtype=float32)> 

<tf.Variable 'w:0' shape=(3, 2) dtype=float32, numpy=
array([[ 1.0474309 , -0.6920227 ],
       [ 1.2405277 ,  0.36411622],
       [-1.6990206 ,  0.762131  ]], dtype=float32)>
 A la espera de crear variables Puede que hayas notado aquí que tienes que definir los tamaños de entrada y salida de la capa. variable tiene una forma conocida y se puede asignar. w Al aplazar la creación de variables a la primera vez que se llama el módulo con una forma de entrada específica, no es necesario especificar el tamaño de la entrada por delante. class FlexibleDenseModule(tf.Module):
  # Note: No need for `in_features`
  def __init__(self, out_features, name=None):
    super().__init__(name=name)
    self.is_built = False
    self.out_features = out_features

  def __call__(self, x):
    # Create variables on first call.
    if not self.is_built:
      self.w = tf.Variable(
        tf.random.normal([x.shape[-1], self.out_features]), name='w')
      self.b = tf.Variable(tf.zeros([self.out_features]), name='b')
      self.is_built = True

    y = tf.matmul(x, self.w) + self.b
    return tf.nn.relu(y)
 # Used in a module
class MySequentialModule(tf.Module):
  def __init__(self, name=None):
    super().__init__(name=name)

    self.dense_1 = FlexibleDenseModule(out_features=3)
    self.dense_2 = FlexibleDenseModule(out_features=2)

  def __call__(self, x):
    x = self.dense_1(x)
    return self.dense_2(x)

my_model = MySequentialModule(name="the_model")
print("Model results:", my_model(tf.constant([[2.0, 2.0, 2.0]])))
 Model results: tf.Tensor([[0. 0.]], shape=(1, 2), dtype=float32)
 Esta flexibilidad es la razón por la que las capas de TensorFlow a menudo solo necesitan especificar la forma de sus salidas, como en , en lugar de tanto el tamaño de la entrada y la salida. tf.keras.layers.Dense Ahorrar pesos Puedes salvar a Como ambos a y a . tf.Module Checkpoint Modelo Salvaje Los puntos de control son sólo los pesos (es decir, los valores del conjunto de variables dentro del módulo y sus submodulos): chkp_path = "my_checkpoint"
checkpoint = tf.train.Checkpoint(model=my_model)
checkpoint.write(chkp_path)
 'my_checkpoint'
 Los puntos de control consisten en dos tipos de archivos: los datos mismos y un archivo de índice para metadatos. El archivo de índice guarda un seguimiento de lo que realmente se guarda y la numeración de los puntos de control, mientras que los datos de los puntos de control contienen los valores variables y sus caminos de búsqueda de atributos. ls my_checkpoint*
 my_checkpoint.data-00000-of-00001  my_checkpoint.index
 Puede mirar dentro de un punto de control para asegurarse de que se guarde toda la colección de variables, ordenada por el objeto de Python que las contiene. tf.train.list_variables(chkp_path)
 [('_CHECKPOINTABLE_OBJECT_GRAPH', []),
 ('model/dense_1/b/.ATTRIBUTES/VARIABLE_VALUE', [3]),
 ('model/dense_1/w/.ATTRIBUTES/VARIABLE_VALUE', [3, 3]),
 ('model/dense_2/b/.ATTRIBUTES/VARIABLE_VALUE', [2]),
 ('model/dense_2/w/.ATTRIBUTES/VARIABLE_VALUE', [3, 2])]
 Durante el entrenamiento distribuido (multi-máquina) pueden ser fragmentados, por lo que son numerados (por ejemplo, '00000-de-00001'). Cuando devuelve los modelos, sobreescribe los valores en su objeto de Python. new_model = MySequentialModule()
new_checkpoint = tf.train.Checkpoint(model=new_model)
new_checkpoint.restore("my_checkpoint")

# Should be the same result as above
new_model(tf.constant([[2.0, 2.0, 2.0]]))
 <tf.Tensor: shape=(1, 2), dtype=float32, numpy=array([[0., 0.]], dtype=float32)>
 
 
 Nota: Como los puntos de control se encuentran en el centro de los flujos de trabajo de formación de larga duración, consulte checkpoint.CheckpointManager es una clase de ayuda que facilita mucho la gestión de los puntos de control. Nota: Como los puntos de control se encuentran en el centro de los flujos de trabajo de formación de larga duración, consulte checkpoint.CheckpointManager es una clase de ayuda que facilita mucho la gestión de los puntos de control. Guía de control de puntos de entrenamiento Funciones de ahorro TensorFlow puede ejecutar modelos sin los objetos originales de Python, como lo demuestra y , incluso cuando descargas un modelo entrenado de TensorFlow Serving TensorFlow Lite TensorFlow Hub. TensorFlow necesita saber cómo hacer los cálculos descritos en Python, pero Para ello, puedes hacer una que se describe en el . without the original code graph Introducción a los gráficos y las funciones Este gráfico contiene operaciones, o que realiza la función. OPS Puede definir un gráfico en el modelo de arriba añadiendo el Decorador para indicar que este código debe ejecutarse como un gráfico. @tf.function class MySequentialModule(tf.Module):
  def __init__(self, name=None):
    super().__init__(name=name)

    self.dense_1 = Dense(in_features=3, out_features=3)
    self.dense_2 = Dense(in_features=3, out_features=2)

  @tf.function
  def __call__(self, x):
    x = self.dense_1(x)
    return self.dense_2(x)

# You have made a model with a graph!
my_model = MySequentialModule(name="the_model")
 El módulo que has creado funciona exactamente igual que antes. Cada firma única pasada a la función crea un gráfico separado. por los detalles. Introducción a los gráficos y las funciones print(my_model([[2.0, 2.0, 2.0]]))
print(my_model([[[2.0, 2.0, 2.0], [2.0, 2.0, 2.0]]]))
 tf.Tensor([[0.31593648 0.        ]], shape=(1, 2), dtype=float32)
tf.Tensor(
[[[0.31593648 0.        ]
  [0.31593648 0.        ]]], shape=(1, 2, 2), dtype=float32)
 Puede visualizar el gráfico rastreándolo dentro de un resumen de TensorBoard. # Set up logging.
stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
logdir = "logs/func/%s" % stamp
writer = tf.summary.create_file_writer(logdir)

# Create a new model to get a fresh trace
# Otherwise the summary will not see the graph.
new_model = MySequentialModule()

# Bracket the function call with
# tf.summary.trace_on() and tf.summary.trace_export().
tf.summary.trace_on(graph=True)
tf.profiler.experimental.start(logdir)
# Call only one tf.function when tracing.
z = print(new_model(tf.constant([[2.0, 2.0, 2.0]])))
with writer.as_default():
  tf.summary.trace_export(
      name="my_func_trace",
      step=0,
      profiler_outdir=logdir)
 tf.Tensor([[0. 0.]], shape=(1, 2), dtype=float32)
 Lanzar TensorBoard para ver el rastro resultante: #docs_infra: no_execute
%tensorboard --logdir logs/func
 Creando a SavedModel La forma recomendada de compartir modelos completamente capacitados es usar . el contiene tanto una colección de funciones como una colección de pesas. SavedModel SavedModel Puede guardar el modelo que acaba de entrenar de la siguiente manera: tf.saved_model.save(my_model, "the_saved_model")
 INFO:tensorflow:Assets written to: the_saved_model/assets
 # Inspect the SavedModel in the directory
ls -l the_saved_model
 total 32
drwxr-sr-x 2 kbuilder kokoro  4096 Oct 18 01:21 assets
-rw-rw-r-- 1 kbuilder kokoro    58 Oct 18 01:21 fingerprint.pb
-rw-rw-r-- 1 kbuilder kokoro 17704 Oct 18 01:21 saved_model.pb
drwxr-sr-x 2 kbuilder kokoro  4096 Oct 18 01:21 variables
 # The variables/ directory contains a checkpoint of the variables
ls -l the_saved_model/variables
 total 8
-rw-rw-r-- 1 kbuilder kokoro 490 Oct 18 01:21 variables.data-00000-of-00001
-rw-rw-r-- 1 kbuilder kokoro 356 Oct 18 01:21 variables.index
 El El archivo es a Describe la funcionalidad . saved_model.pb El protocolo buffer tf.Graph Esto es deseable en situaciones donde no tienes (o quieres) un intérprete de Python, como servir en escala o en un dispositivo de borde, o en situaciones donde el código original de Python no está disponible o práctico para usar. Puede cargar el modelo como nuevo objeto: new_model = tf.saved_model.load("the_saved_model")
 , creado a partir de la carga de un modelo guardado, es un objeto de usuario interno TensorFlow sin ningún conocimiento de la clase. . new_model SequentialModule isinstance(new_model, SequentialModule)
 False
 Este nuevo modelo funciona con las firmas de entrada ya definidas. No se pueden añadir más firmas a un modelo restaurado como este. print(my_model([[2.0, 2.0, 2.0]]))
print(my_model([[[2.0, 2.0, 2.0], [2.0, 2.0, 2.0]]]))
 tf.Tensor([[0.31593648 0.        ]], shape=(1, 2), dtype=float32)
tf.Tensor(
[[[0.31593648 0.        ]
  [0.31593648 0.        ]]], shape=(1, 2, 2), dtype=float32)
 Por lo tanto, utilizando , es posible guardar pesos y gráficos de TensorFlow utilizando Y luego los cargamos de nuevo. SavedModel tf.Module 
 
 Originalmente publicado en el sitio web de TensorFlow, este artículo aparece aquí bajo un nuevo título y está licenciado bajo CC BY 4.0. Originalmente publicado en el sitio web de TensorFlow, este artículo aparece aquí bajo un nuevo título y está licenciado bajo CC BY 4.0. TensorFlow

Este audio es producido en el idioma original de la historia!

Demasiado Largo; Para Leer

Make resilience your competitive advantage

Cómo definir, guardar y restaurar modelos en TensorFlow

About Author

COMENTARIOS

ETIQUETAS

ESTE ARTÍCULO FUE PRESENTADO EN

Related Stories

Crecimiento de las criptomonedas: creación de perfiles de usuarios eficaces

Liberando el poder de la IA. Una revisión sistemática de técnicas de vanguardia: resumen e introducción

Valhalla de Floki se une como patrocinador asociado de la gira de la India por Sri Lanka

Creación de productos criptográficos centrados en el usuario: la importancia de los comentarios de los clientes

Crecimiento de las criptomonedas: creación de perfiles de usuarios eficaces

Liberando el poder de la IA. Una revisión sistemática de técnicas de vanguardia: resumen e introducción

Valhalla de Floki se une como patrocinador asociado de la gira de la India por Sri Lanka

Creación de productos criptográficos centrados en el usuario: la importancia de los comentarios de los clientes

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps