Regardez les keynotes, les sessions sur les produits, les ateliers et bien plus à partir de Google I / O Voir la playlist

Neural Structured Learning : Entraînement avec des signaux structurés

Neural Structured Learning (NSL) est un nouveau paradigme d'apprentissage permettant d'entraîner des réseaux de neurones avec des signaux structurés en plus des entrées de caractéristiques. La structure peut être explicite, telle que représentée par un graphe, ou implicite, comme induite par une perturbation antagoniste.

Les signaux structurés sont généralement utilisés pour représenter des relations ou une similarité entre des exemples auxquels des étiquettes peuvent être ajoutées ou retirées. Par conséquent, si vous exploitez ces signaux pendant l'entraînement du réseau de neurones, des données avec étiquette et sans étiquette sont utilisées. Cela peut améliorer la justesse du modèle, en particulier lorsque les données étiquetées sont relativement peu nombreuses. En outre, les modèles qui sont entraînés avec des exemples générés en ajoutant une perturbation antagoniste se sont révélés très efficaces contre les attaques malveillantes, lesquelles sont conçues pour tromper la prédiction ou la classification d'un modèle.

NSL se généralise à l'apprentissage de graphes neuronaux ainsi qu'à l'apprentissage antagoniste. Le framework NSL de TensorFlow fournit les API et les outils ci-dessous. Faciles à utiliser, ils permettent aux développeurs d'entraîner des modèles avec des signaux structurés :

  • Les API Keras permettent l'entraînement avec des graphes (structure explicite) et des perturbations antagonistes (structure implicite).
  • Les opérations et fonctions de TF permettent un entraînement avec structure lors de l'utilisation d'API TensorFlow de niveau inférieur
  • Les outils permettent de créer des graphes et de construire des entrées de graphe pour l'entraînement

L'intégration des signaux structurés s'effectue uniquement au cours de l'entraînement. Par conséquent, les performances du workflow d'inférence restent inchangées. Pour en savoir plus sur Neural Structured Learning, consultez notre description du framework. Pour commencer, reportez-vous au guide d'installation. Pour une présentation pratique du NSL, nous vous invitons à consulter nos tutoriels.

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})