Se usó la API de Cloud Translation para traducir esta página.
Switch to English

Formato TF1 Hub

En su lanzamiento en 2018, TensorFlow Hub ofreció un único 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 Estimator TF1, 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 .

Usar un modelo en formato TF1 Hub

Crear instancias de un modelo en formato TF1 Hub

Un modelo en formato TF1 Hub se importa a un programa TensorFlow creando un objeto hub.Module desde 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. La ejecución de sus inicializadores leerá sus valores pre-entrenados del disco. Del mismo modo, las tablas y otros estados se agregan al gráfico.

Módulos de almacenamiento en caché

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

Aplicando 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 actual de TensorFlow para calcular y desde x . Si esto involucra variables con pesos entrenados, estos 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 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 múltiples 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 as_dict=True pasando as_dict=True , debajo de las claves definidas por la firma (la clave "default" es para la salida única 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 suministrar todas las entradas definidas por una firma, pero no es necesario usar todas las salidas de un módulo. TensorFlow ejecutará solo aquellas partes del módulo que terminan como dependencias de un objetivo en tf.Session.run() . De hecho, los editores de módulos pueden optar por proporcionar varias salidas para usos avanzados (como activaciones de capas intermedias) junto con las salidas principales. Los consumidores de módulos deben manejar salidas adicionales con gracia.

Probar módulos alternativos

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

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

Crear un nuevo módulo

Nota de compatibilidad

El formato TF1 Hub está dirigido a TensorFlow 1. TF Hub solo lo admite parcialmente en TensorFlow 2. Considere la posibilidad de publicar en el nuevo formato TF2 SavedModel .

El formato TF1 Hub es similar al formato SavedModel de TensorFlow 1 en un nivel sintáctico (mismos nombres de archivo y mensajes de protocolo) pero semánticamente diferente para permitir la reutilización, composición y reentrenamiento de módulos (por ejemplo, diferente almacenamiento 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, usando tf.placeholder() para las entradas que 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 TensorFlow particular. En tal caso, no hay un punto de control, y la instancia del módulo usará los inicializadores 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 utilizar 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

La capacitación 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 busquen un 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, hub.Module(..., trainable=True) instancia del módulo con hub.Module(..., trainable=True) para que sus variables sean entrenables e importe REGULARIZATION_LOSSES de TensorFlow. Si el módulo tiene múltiples variantes de gráficos, asegúrese de elegir el apropiado 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 pre-entrenados, por ejemplo, una tasa de aprendizaje más baja que para el entrenamiento desde cero.

Para editores

Para facilitar el ajuste a los consumidores, tenga en cuenta lo siguiente:

  • El ajuste fino necesita regularización. Su módulo se exporta con la colección REGULARIZATION_LOSSES , que es lo que pone 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 editor, 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 establecer las fortalezas de regularización a nivel mundial puede no ser apropiado para el consumidor. Excepto por 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.

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