Aprendizaje Estructurado Neuronal: entrenamiento con señales estructuradas

El Aprendizaje Estructurado Neuronal (NSL) es un nuevo paradigma de aprendizaje para entrenar redes neuronales mediante el uso de señales estructuradas junto con entradas de atributos. La estructura puede ser explícita, representada por un grafo, o implícita, inducida por una perturbación adversaria.

Las señales estructuradas se usan habitualmente para representar relaciones o similitudes entre muestras que pueden estar etiquetadas o no. Por lo tanto, si se utilizan estas señales durante el entrenamiento de la red neuronal se pueden aprovechar los datos etiquetados y no etiquetados, lo que puede mejorar la exactitud del modelo, en particular cuando la cantidad de datos etiquetados es relativamente pequeña. Además, se demostró que los modelos entrenados con muestras generadas al agregar perturbación adversaria son resistentes a los ataques maliciosos, que están diseñados para generar errores en la predicción o clasificación de un modelo.

El NSL generaliza el aprendizaje con grafos neuronales y el aprendizaje adversario. El marco de trabajo del NSL en TensorFlow proporciona las siguientes API y herramientas fáciles de usar para que los desarrolladores entrenen modelos con señales estructuradas:

  • Las API de Keras para permitir el entrenamiento con grafos (estructura explícita) y perturbaciones adversarias (estructura implícita)
  • Operaciones y funciones de TF para habilitar el entrenamiento con estructura cuando se usan API de TensorFlow de nivel inferior
  • Herramientas para compilar grafos y generar entradas de grafos para el entrenamiento

La incorporación de señales estructuradas solo se realiza durante el entrenamiento. Por lo tanto, el rendimiento del flujo de trabajo de deriva o inferencia no cambia. Puedes encontrar más información sobre el aprendizaje estructurado neuronal en nuestra descripción del marco de trabajo. Para comenzar, consulta nuestra guía de instalación y, para obtener una introducción práctica al NSL, consulta nuestros instructivos.

import tensorflow as tf
import neural_structured_learning as nsl

# Prepare data.
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

# Create a base model -- sequential, functional, or subclass.
model = tf.keras.Sequential([
    tf.keras.Input((28, 28), name='feature'),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(128, activation=tf.nn.relu),
    tf.keras.layers.Dense(10, activation=tf.nn.softmax)
])

# Wrap the model with adversarial regularization.
adv_config = nsl.configs.make_adv_reg_config(multiplier=0.2, adv_step_size=0.05)
adv_model = nsl.keras.AdversarialRegularization(model, adv_config=adv_config)

# Compile, train, and evaluate.
adv_model.compile(optimizer='adam',
                  loss='sparse_categorical_crossentropy',
                  metrics=['accuracy'])
adv_model.fit({'feature': x_train, 'label': y_train}, batch_size=32, epochs=5)
adv_model.evaluate({'feature': x_test, 'label': y_test})