Cualquier marco de aprendizaje profundo para tener éxito tiene que
proporcionar una buena colección de redes neuronales de vanguardia, junto con
sus pesos entrenados en conjuntos de datos populares y ampliamente aceptados.
Muchos marcos generalmente se refieren a esta colección como Model Zoo. TensorFlow
en sus versiones iniciales proporcionó este zoológico de redes a través de su
marco TF-Slim. Pero la usabilidad de TF-Slim para las redes no era intuitiva y,
con el tiempo, TF-Slim quedo en desuso.
TensorFlow,
ahora ha creado un marco mejor conocido como TensorFlow Hub, que es muy fácil
de usar y está bien organizado. Con TensorFlow Hub, podemos realizar con
confianza la actividad ampliamente utilizada de Transfer Learning al importar
redes grandes y populares en unas pocas líneas de código. TensorFlow Hub es muy
flexible y proporciona la posibilidad de alojar nuestras redes para que otros
usuarios las utilicen. Estas redes en TensorFlow Hub se denominan módulos.
En
este artículo, echaremos un vistazo a los conceptos básicos sobre cómo usar
TensorFlow Hub, sus diversos tipos y ejemplos de código.
Es
importante tener en cuenta que TensorFlow Hub solo proporciona un gráfico que
comprende la arquitectura de la red junto con sus pesos entrenados en ciertos
conjuntos de datos. La mayoría de los módulos dan acceso a capas internas de la
red que se pueden usar en función de diferentes casos de uso. Sin embargo,
algunos de los módulos no son ajustables. Antes de comenzar con el desarrollo,
es recomendable consultar la descripción proporcionada sobre el módulo en el
sitio web de TensorFlow Hub.
A
continuación, veremos algunos aspectos y funciones importantes que se pueden
utilizar para comprender más detalles sobre el módulo del TensorFlow Hub.
Prerrequisitos
Instanciación
En TensorFlow Hub se alojan varios módulos formados con
diferentes redes (Inception, ResNet, ElMo, etc.) que sirven para diferentes
propósitos (clasificación de imágenes, incrustaciones de texto, etc.). El
usuario tiene que navegar por el catálogo de módulos y luego, una vez
finalizado su propósito, necesitamos copiar la URL donde está alojada la red.
Luego, podemos instanciar nuestro módulo de la siguiente forma:
import
tensorflow_hub as hub
module =
hub.Module(<<Module URL as
string>>, trainable=True)
Además
del parámetro URL, el otro parámetro más notable es "trainable". Si
deseamos ajustar / modificar los pesos
del modelo, este parámetro debe establecerse como Verdadero.
Firma
La
firma del módulo especifica para qué se utiliza el módulo. Todo el módulo viene
con la firma "predeterminada" y la utiliza, si una firma no se
menciona explícitamente. Para la mayoría de los módulos, cuando se utiliza la
firma "predeterminada", las capas internas del modelo se abstraen del
usuario. La función utilizada para enumerar todos los nombres de firma del
módulo es get_signature_names ().
import
tensorflow_hub as hub
module =
hub.Module('https://tfhub.dev/google/imagenet/inception_v3/classification/1')
print(module.get_signature_names())
# ['default', 'image_classification', 'image_feature_vector']
Entradas
esperadas
Cada
módulo tiene un conjunto de entradas esperadas dependiendo de la firma del
módulo que se esté utilizando. Aunque la mayoría de los módulos han documentado
el conjunto de entradas esperadas en el sitio web de TensorFlow Hub
(particularmente para la firma "predeterminada"), algunos de ellos no
lo han hecho. En este caso, es más fácil obtener la entrada esperada junto con
su tamaño y tipo de datos usando get_input_info_dict ().
import
tensorflow_hub as hub
module =
hub.Module('https://tfhub.dev/google/imagenet/inception_v3/classification/1')
print(module.get_input_info_dict())
# When no
signature is given, considers it as 'default'# {'images': <hub.ParsedTensorInfo
shape=(?, 299, 299, 3) dtype=float32 is_sparse=False>}
print(module.get_input_info_dict(signature='image_feature_vector')) # {'images': <hub.ParsedTensorInfo shape=(?, 299, 299, 3)
dtype=float32 is_sparse=False>}
Resultados
esperados
Para
construir la parte restante del gráfico después de que se construye el modelo
de TensorFlow Hub, es necesario conocer el tipo de salida esperado. La función
get_output_info_dict () se usa para este propósito. Hay que tener en cuenta que
para la firma "predeterminada", generalmente habrá solo una salida,
pero cuando utilizamos una firma no predeterminada, se expondrán varias capas
del gráfico.
import
tensorflow_hub as hub
module =
hub.Module('https://tfhub.dev/google/imagenet/inception_v3/classification/1')
print(module.get_output_info_dict())
# When no
signature is given, considers it as 'default'
# {'default': <hub.ParsedTensorInfo shape=(?, 1001)
dtype=float32 is_sparse=False>}
print(module.get_output_info_dict(signature='image_classification'))
# {'InceptionV3/global_pool': <hub.ParsedTensorInfo shape=(?,
1, 1, 2048) dtype=float32 is_sparse=False>,
# 'InceptionV3/Logits': <hub.ParsedTensorInfo shape=(?, 1001)
dtype=float32 is_sparse=False>,
# 'InceptionV3/Conv2d_2b_3x3': <hub.ParsedTensorInfo shape=(?,
147, 147, 64) dtype=float32 is_sparse=False>
# ..... Several other exposed layers...... }
Recopilación
de las capas necesarias del módulo
Después
de crear una instancia del módulo, debemos extraer la capa/salida deseada del
módulo y agregarla al gráfico. Estas son algunas de las formas de hacerlo:
import
tensorflow as tf
import
tensorflow_hub as hub
images =
tf.placeholder(tf.float32, (None, 299, 299, 3))
module =
hub.Module('https://tfhub.dev/google/imagenet/inception_v3/classification/1')
logits1 =
module(dict(images=images))
# implies
default signature
print(logits1)
# Tensor("module_apply_default/InceptionV3/Logits/SpatialSqueeze:0",
shape=(?, 1001), dtype=float32)
module_features =
module(dict(images=images),
signature='image_classification', as_dict=True)
# module_features stores all layers in key-value pairs
logits2 =
module_features['InceptionV3/Logits']
print(logits2)
#
Tensor("module_apply_image_classification/InceptionV3/Logits/SpatialSqueeze:0",
shape=(?, 1001), dtype=float32)
global_pool =
module_features['InceptionV3/global_pool']
print(global_pool)
# Tensor("module_apply_image_classification/InceptionV3/Logits/GlobalPool:0",
shape=(?, 1, 1, 2048), dtype=float32)
Inicialización
de las operaciones de TensorFlow Hub
TensorFlow
Hub aloja el peso / valores de salida resultantes de todas las operaciones
presentes en los módulos en formato tabular. Esto debe inicializarse usando
tf.tables_initializer () junto con las inicializaciones de variables regulares.
El bloque de código se ve así:
import
tensorflow as tf
with
tf.Session() as sess:
sess.run([tf.tables_initializer(), <<other initializers>>])
Bloque
de esqueleto de código
Una
vez que se construye el gráfico completo que comprende su módulo, optimizadores
de algoritmos de aprendizaje, función objetivo, capas personalizadas, etc., así
es como puede verse la parte gráfica de su código.
import tensorflow as tf
import tensorflow_hub as hub
<< Create Placeholders >>
<< Create Dataset and Iterators >>
module1 = hub.Module(<< Module URL >>)
logits1 =
module1(<< input_dict >>)
module2 =
hub.Module(<< Module URL
>>)
module2_features =
module2(<< input_dict >>, signature='default', as_dict=True)
logits2 =
module2_features['default']
<<
Remaining graph, learning algorithms, objective function, etc >>
with
tf.Session() as sess:
sess.run([tf.tables_initializer(), <<
other initializers >>])
<< Remaining training pipeline >>
Estamos
haciendo uso de dos módulos. El primer módulo se construye utilizando un código
mínimo básico que utiliza implícitamente la firma y la capa predeterminadas. En
el segundo módulo, especifica explícitamente la firma y la capa
predeterminadas. De manera similar, podemos especificar la firma y las capas no
predeterminadas.
Ahora
que hemos analizado cómo integrar un módulo en el gráfico, veamos varios tipos
de módulos presentes en TensorFlow Hub. En cada uno de los ejemplos, se ha
integrado con el conjunto de datos y la tubería Iterator y guardado con
Saved_Model.
Módulos
de clasificación de imágenes
Como
su nombre indica, este conjunto de módulos se utilizan para la clasificación de
imágenes. En esta categoría de módulos, se proporciona la arquitectura completa
de la red. Esto incluye la capa densa final que se usa para la clasificación.
En el ejemplo de código para esta categoría, solo vamos a ver el problema de
clasificación de perros y gatos de Kaggle en 1001 clases ImageNet usando el
módulo Inception V3.
import tensorflow as tf
import tensorflow_hub as hub
from Dataset import Dataset
tf.reset_default_graph()
dataset = Dataset()
module = hub.Module('https://tfhub.dev/google/imagenet/inception_v3/classification/1')
logits = module(dict(images=dataset.img_data))
softmax = tf.nn.softmax(logits)
top_predictions = tf.nn.top_k(softmax, top_k, name='top_predictions')
Si
imprimimos las firmas de estos módulos, la mayoría de ellos tendrá un total de
tres firmas que son "predeterminadas", "clasificación_imagen"
e "imagen_feature_vector". Aunque la firma de
"image_feature_vector" aparece en esta categoría de módulos, esta
firma exhibirá características similares a las de la categoría de módulos de
vectores de características que se explica a continuación.
Módulos
de vectores de características
Esto
es muy similar al de los módulos de clasificación de imágenes, con la única
diferencia de que el módulo no incluye la capa de clasificación densa final. En
el ejemplo de código para esta categoría, voy a ajustar el módulo Resnet-50
para el problema de clasificación de atributos de animales con múltiples
etiquetas de Hackerearth.
Durante
la operación de ajuste, muy a menudo, se hace necesario optimizar las capas
finales del módulo además de las capas densas anexas de manera personalizada.
Durante tales escenarios, tendremos que encontrar los nombres del alcance o las
variables que deseamos ajustar. Se adjunta la parte relevante del código para
realizar dicho procedimiento en el Módulo de vectores de características.
Module =
hub.Module('https://tfhub.dev/google/imagenet/resnet_v2_50/feature_vector/1',
trainable=True) # Trainable is True since we are going to
fine-tune the model
module_features
= module(dict(images=dataset.image_data), signature="image_feature_vector",
as_dict=True)
features =
module_features["default"]
with
tf.variable_scope('CustomLayer'):
weight = tf.get_variable('weights',
initializer=tf.truncated_normal((2048, n_class)))
bias = tf.get_variable('bias',
initializer=tf.ones((n_class)))
logits = tf.nn.xw_plus_b(features, weight,
bias)
# Find out the
names of all variables present in graph
print(tf.all_variables())
# After finding
the names of variables or scope, gather the variables you wish to fine-tune
var_list =
tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='CustomLayer')
var_list2 =
tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES,
scope='module/resnet_v2_50/block4')
var_list.extend(var_list2)
# Pass this set
of variables into your optimiser
optimizer =
tf.train.AdamOptimizer(learning_rate=lr).minimize(loss, var_list=var_list)
Código
de función del vector que muestra cómo ajustar las capas del módulo
Si
los nodos en el gráfico del módulo no se nombran intuitivamente (escenario muy
poco probable), tendremos que descubrir la arquitectura del módulo y luego
asignarlos a los nodos que se están imprimiendo.
En
el ejemplo de código, Se han ajustado las variables finales de las pocas capas
que se encuentran dentro del alcance variable de "resnet_v2_50 /
block4". Al entrenar durante 10 épocas, obtendremos un puntaje de F1 de
0.95819 sin esfuerzo para este problema.
Módulos
de clasificación de video
La
clasificación de video se refiere a categorizar la naturaleza de las actividades
que ocurren en un video clip. En el ejemplo de código, se ha entrenado el
conjunto de datos 20BN-Jester que consta de 27 clases en el módulo Inception
3D. Nuevamente, con solo 3 épocas de entrenamiento, he logrado un puntaje de
91.45% de precisión. La parte relevante del código del módulo se muestra a
continuación.
import tensorflow as tf
import
tensorflow_hub as hub
from Dataset
import Dataset
dataset =
Dataset()
module =
hub.Module("https://tfhub.dev/deepmind/i3d-kinetics-400/1",
trainable=True)
features =
module(dict(rgb_input=dataset.image_data))
n_class = 27
with
tf.variable_scope('CustomLayer'):
weight = tf.get_variable('weights',
initializer=tf.truncated_normal((400, n_class)))
bias = tf.get_variable('bias',
initializer=tf.ones((n_class)))
logits =
tf.nn.xw_plus_b(features, weight, bias)
Para
probar la precisión del modelo, se creó una aplicación simple de clasificación
de vídeo en tiempo real y aquí hay un pequeño vídeo.
Clasificación
de vídeo en tiempo real construida utilizando TensorFlow Hub
Módulos
de incrustación de texto
TensorFlow
Hub ha suministrado varios módulos de incrustación de texto no solo en inglés
sino también en varios otros idiomas como alemán, coreano, japonés, etc.,
muchos de ellos producen incrustaciones a nivel de oración y no a nivel de
oración. nivel de palabra En el ejemplo del código, se ha trabajado en el
análisis de sentimientos de Kaggle sobre la crítica de películas. Usando el
módulo de incrustaciones ELMO, se entrenó una la red usando incrustaciones
producidas a nivel de oración y palabra por separado. La red se compone de una
sola capa de LSTM bidireccional. A nivel de la oración, después de entrenar
durante 6 épocas, la precisión alcanzada fue del 65%. Adjuntando la parte
relevante del código del módulo Incorporación de texto de TensorFlow Hub
module = hub.Module('https://tfhub.dev/google/elmo/2',
trainable=True)
embeddings =
module(dict(text=dataset.text_data))
embeddings =
tf.expand_dims(embeddings, axis=1)
with tf.variable_scope('Layer1'):
cell_fw1 =
tf.nn.rnn_cell.LSTMCell(num_units=128, state_is_tuple=True)
cell_bw1 =
tf.nn.rnn_cell.LSTMCell(num_units=128, state_is_tuple=True)
outputs1, states1 =
tf.nn.bidirectional_dynamic_rnn(
cell_fw=cell_fw1,
cell_bw=cell_bw1,
inputs=embeddings)
rnn_output =
tf.reshape(outputs1[0], (-1, 128))
with
tf.variable_scope('Layer2'):
weight2 = tf.get_variable('weight',
initializer=tf.truncated_normal((128, n_class)))
bias2 = tf.get_variable('bias',
initializer=tf.ones(n_class))
logits =
tf.nn.xw_plus_b(rnn_output, weight2, bias2)
Módulos
de aumento de imagen
El
aumento de imagen es un componente esencial en el proceso de capacitación para
aumentar la precisión de una red. Ninguno de los módulos de aumento de imagen
tiene ninguna variable en ellos, y en consecuencia, estos módulos no son
ajustables / entrenables. Con la firma de "from_decoded_images",
podemos alimentar directamente las imágenes a estos módulos. A continuación se
muestra un bloque de código de ejemplo junto con las imágenes aumentadas
generadas.
import tensorflow as tf
import
tensorflow_hub as hub
import
tensorflow.contrib.image #
Needed for Image Augmentation modules
from Dataset
import Dataset
dataset =
Dataset()
module =
hub.Module('https://tfhub.dev/google/image_augmentation/nas_svhn/1')
input_dict =
dict(image_size=image_size, # Output Image size
images=dataset.img_data, # Has the image in Numpy data format
augmentation=True)
aug_images = module(input_dict,
signature='from_decoded_images')
La
utilidad real del aumento de imagen se produce cuando agrupamos este módulo con
otros módulos de clasificación de imágenes, vector de características, etc. En
el problema de clasificación de atributos de animales multi-etiqueta
previamente entrenado usando el módulo Feature Vector, se agregó el módulo de
aumento de imagen crop_color, y con el mismo número de épocas, el puntaje F1
mejora a 0.96244. En este ejemplo de código, se utiliza la firma
predeterminada, que esperará que la imagen en forma codificada sea su entrada.
Ahora, a medida que el módulo de aumento de imagen redimensiona la imagen de
entrada a un tamaño fijo para su posterior procesamiento por el módulo
Resnet50, se ha guardado el trabajo de cambiar explícitamente el tamaño de las
imágenes, lo que había hecho anteriormente.
import tensorflow as tf
import
tensorflow_hub as hub
import
tensorflow.contrib.image #
Needed for Image Augmentation modules
aug_module =
hub.Module('https://tfhub.dev/google/image_augmentation/crop_color/1')
aug_features =
aug_module(dict(encoded_images=dataset.encoded_img_data,
image_size=image_size,
augmentation=is_training)) # No
augmentation needed for test and validation pipeline
resnet_module = hub.Module('https://tfhub.dev/google/imagenet/resnet_v2_50/feature_vector/1',
trainable=True)
img_features =
resnet_module(dict(images=aug_features))
with
tf.variable_scope('CustomLayer'):
weight = tf.get_variable('weights',
initializer=tf.truncated_normal((2048, n_class)))
bias = tf.get_variable('bias',
initializer=tf.ones((n_class)))
logits =
tf.nn.xw_plus_b(img_features, weight, bias)
Módulos
de detección de objetos
Los
módulos de detección de objetos no son compatibles con el ajuste fino, por lo
que tendremos que realizar un entrenamiento desde cero si tiene su propio
conjunto de datos. El procesamiento por lotes de los datos tampoco es
compatible en este momento. En el ejemplo de código, solo realizaremos
inferencias en las imágenes usando FasterRCNN en el módulo Inception-ResNet V2.
Se ha adjuntado la parte del módulo de código e imágenes generadas a partir del
módulo a continuación.
import tensorflow as tf
import
tensorflow_hub as hub
from Dataset
import Dataset
dataset =
Dataset()
module =
hub.Module('https://tfhub.dev/google/faster_rcnn/openimages_v4/inception_resnet_v2/1')
detector =
module(dict(images=dataset.image_data), as_dict=True)
class_entities =
detector['detection_class_entities']
boxes =
detector['detection_boxes']
scores =
detector['detection_scores']
class_labels =
detector['detection_class_labels']
class_names = detector['detection_class_names']
Módulos
generadores
Estos
corresponden a Redes Adversales Generativas (GAN). Algunos de los módulos no
han expuesto su parte Discriminadora de la red. Al igual que la detección de
objetos, incluso aquí en la muestra de código, solo realizaremos inferencia.
Usando el módulo Progressive GANs que está capacitado en el conjunto de datos
CelebA, generaremos nuevas caras. Se ha adjuntado la parte del módulo de código
e imágenes generadas a partir del módulo a continuación.
import tensorflow as tf
import
tensorflow_hub as hub
from Dataset
import Dataset
dataset =
Dataset()
module =
hub.Module("https://tfhub.dev/google/progan-128/1")
images = module(dataset.latent_vector_space)
Para
ver el código completo integrado con Dataset e Iterators, y guardado con
Saved_Model, consultar el código en el repositorio de GitHub.
