Asista al Simposio Mujeres en ML el 7 de diciembre Regístrese ahora

Formato del concentrador TF1

Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

En su lanzamiento en 2018, TensorFlow Hub ofreció un solo tipo de activo: el formato TF1 Hub para importar a los programas TensorFlow 1.

Esta página explica cómo usar el formato TF1 Hub en TF1 (o el modo de compatibilidad TF1 de TF2) con la clase hub.Module y las API asociadas. (El uso típico es construir un tf.Graph , posiblemente dentro de un TF1 Estimator , combinando uno o más modelos en formato TF1 Hub con tf.compat.layers o tf.layers ).

Los usuarios de TensorFlow 2 (fuera del modo de compatibilidad TF1) deben usar la nueva API con hub.load() o hub.KerasLayer . La nueva API carga el nuevo tipo de activo TF2 SavedModel, pero también tiene soporte limitado para cargar el formato TF1 Hub en TF2 .

Usando un modelo en formato TF1 Hub

Instanciando un modelo en formato TF1 Hub

Un modelo en formato TF1 Hub se importa a un programa TensorFlow mediante la creación de un objeto hub.Module a partir de una cadena con su URL o ruta del sistema de archivos, como:

m = hub.Module("path/to/a/module_dir")

Esto agrega las variables del módulo al gráfico actual de TensorFlow. Ejecutar sus inicializadores leerá sus valores pre-entrenados del disco. Asimismo, se agregan tablas y otros estados al gráfico.

Módulos de almacenamiento en caché

Al crear un módulo a partir de una URL, el contenido del módulo se descarga y se almacena en caché en el directorio temporal del sistema local. La ubicación donde se almacenan en caché los módulos se puede anular mediante la variable de entorno TFHUB_CACHE_DIR . Para obtener más información, consulte Almacenamiento en caché .

Aplicar un módulo

Una vez instanciado, un módulo m puede llamarse cero o más veces como una función de Python desde entradas de tensor hasta salidas de tensor:

y = m(x)

Cada una de estas llamadas agrega operaciones al gráfico TensorFlow actual para calcular y a partir de x . Si se trata de variables con pesos entrenados, estas se comparten entre todas las aplicaciones.

Los módulos pueden definir múltiples firmas con nombre para permitir que se apliquen en más de una forma (similar a cómo los objetos de Python tienen métodos ). La documentación de un módulo debe describir las firmas disponibles. La llamada anterior aplica la firma denominada "default" . Se puede seleccionar cualquier firma pasando su nombre al argumento opcional signature= .

Si una firma tiene varias entradas, deben pasarse como un dict, con las claves definidas por la firma. Del mismo modo, si una firma tiene múltiples salidas, estas se pueden recuperar como un dictado pasando as_dict=True , bajo las claves definidas por la firma (la clave "default" es para la única salida devuelta si as_dict=False ). Entonces, la forma más general de aplicar un módulo se ve así:

outputs = m(dict(apples=x1, oranges=x2), signature="fruit_to_pet", as_dict=True)
y1 = outputs["cats"]
y2 = outputs["dogs"]

Una persona que llama debe proporcionar todas las entradas definidas por una firma, pero no hay ningún requisito para utilizar todas las salidas de un módulo. TensorFlow ejecutará solo aquellas partes del módulo que terminen como dependencias de un objetivo en tf.Session.run() . De hecho, los editores de módulos pueden elegir proporcionar varias salidas para usos avanzados (como activaciones de capas intermedias) junto con las salidas principales. Los consumidores del módulo deben manejar las salidas adicionales con gracia.

Probar módulos alternativos

Siempre que haya varios módulos para la misma tarea, TensorFlow Hub recomienda equiparlos con firmas (interfaces) compatibles, de modo que probar diferentes sea tan fácil como variar el controlador del módulo como un hiperparámetro con valor de cadena.

Con este fin, mantenemos una colección de firmas comunes recomendadas para tareas populares.

Creación de un nuevo módulo

Nota de compatibilidad

El formato TF1 Hub está orientado a TensorFlow 1. TF Hub solo es parcialmente compatible con TensorFlow 2. Considere publicar en el nuevo formato TF2 SavedModel en su lugar.

El formato TF1 Hub es similar al formato de modelo guardado de TensorFlow 1 en un nivel sintáctico (los mismos nombres de archivo y mensajes de protocolo) pero semánticamente diferente para permitir la reutilización, composición y reentrenamiento del módulo (por ejemplo, almacenamiento diferente de inicializadores de recursos, etiquetado diferente). convenciones para metagrafías). La forma más fácil de distinguirlos en el disco es la presencia o ausencia del archivo tfhub_module.pb .

Enfoque general

Para definir un nuevo módulo, un editor llama a hub.create_module_spec() con una función module_fn . Esta función construye un gráfico que representa la estructura interna del módulo, utilizando tf.placeholder() para las entradas que debe proporcionar la persona que llama. Luego define las firmas llamando a hub.add_signature(name, inputs, outputs) una o más veces.

Por ejemplo:

def module_fn():
  inputs = tf.placeholder(dtype=tf.float32, shape=[None, 50])
  layer1 = tf.layers.dense(inputs, 200)
  layer2 = tf.layers.dense(layer1, 100)
  outputs = dict(default=layer2, hidden_activations=layer1)
  # Add default signature.
  hub.add_signature(inputs=inputs, outputs=outputs)

...
spec = hub.create_module_spec(module_fn)

El resultado de hub.create_module_spec() se puede usar, en lugar de una ruta, para instanciar un objeto de módulo dentro de un gráfico de TensorFlow en particular. En tal caso, no hay ningún punto de control y la instancia del módulo usará los inicializadores de variables en su lugar.

Cualquier instancia de módulo se puede serializar en el disco a través de su método de export(path, session) . La exportación de un módulo serializa su definición junto con el estado actual de sus variables en session en la ruta pasada. Esto se puede usar al exportar un módulo por primera vez, así como al exportar un módulo ajustado.

Para compatibilidad con TensorFlow Estimators, hub.LatestModuleExporter exporta módulos desde el último punto de control, al igual que tf.estimator.LatestExporter exporta todo el modelo desde el último punto de control.

Los editores de módulos deben implementar una firma común cuando sea posible, para que los consumidores puedan intercambiar módulos fácilmente y encontrar el mejor para su problema.

ejemplo real

Eche un vistazo a nuestro exportador de módulos de incrustación de texto para ver un ejemplo real de cómo crear un módulo a partir de un formato de incrustación de texto común.

Sintonia FINA

El entrenamiento de las variables de un módulo importado junto con las del modelo que lo rodea se denomina ajuste fino . El ajuste fino puede dar como resultado una mejor calidad, pero agrega nuevas complicaciones. Aconsejamos a los consumidores que consideren el ajuste fino solo después de explorar ajustes de calidad más simples, y solo si el editor del módulo lo recomienda.

Para consumidores

Para habilitar el ajuste fino, cree una instancia del módulo con hub.Module(..., trainable=True) para hacer que sus variables se puedan entrenar e importe REGULARIZATION_LOSSES de TensorFlow. Si el módulo tiene varias variantes de gráficos, asegúrese de elegir la adecuada para el entrenamiento. Por lo general, ese es el que tiene las etiquetas {"train"} .

Elija un régimen de entrenamiento que no arruine los pesos preentrenados, por ejemplo, una tasa de aprendizaje más baja que para entrenar desde cero.

Para editores

Para que el ajuste sea más fácil para los consumidores, tenga en cuenta lo siguiente:

  • El ajuste necesita regularización. Su módulo se exporta con la colección REGULARIZATION_LOSSES , que es lo que coloca su elección de tf.layers.dense(..., kernel_regularizer=...) etc. en lo que el consumidor obtiene de tf.losses.get_regularization_losses() . Prefiera esta forma de definir las pérdidas de regularización L1/L2.

  • En el modelo de publicación, evite definir la regularización L1/L2 a través de los parámetros l1_ y l2_regularization_strength de tf.train.FtrlOptimizer , tf.train.ProximalGradientDescentOptimizer y otros optimizadores proximales. Estos no se exportan junto con el módulo, y es posible que establecer los puntos fuertes de regularización globalmente no sea apropiado para el consumidor. Excepto para la regularización L1 en modelos anchos (es decir, lineales dispersos) o anchos y profundos, debería ser posible utilizar pérdidas de regularización individuales en su lugar.

  • Si usa abandono, normalización por lotes o técnicas de entrenamiento similares, establezca sus hiperparámetros en valores que tengan sentido para muchos usos esperados. Es posible que la tasa de deserción deba ajustarse a la propensión de sobreajuste del problema objetivo. En la normalización por lotes, el impulso (también conocido como coeficiente de decaimiento) debe ser lo suficientemente pequeño como para permitir el ajuste fino con conjuntos de datos pequeños y/o lotes grandes. Para consumidores avanzados, considere agregar una firma que exponga el control sobre hiperparámetros críticos.