Assistez au symposium Women in ML le 7 décembre Inscrivez-vous maintenant
Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Apprentissage neuronal structuré : entraînement avec des signaux structurés

L'apprentissage structuré neuronal (NSL) est un nouveau paradigme d'apprentissage pour former des réseaux de neurones en exploitant des signaux structurés en plus des entrées de fonctionnalités. La structure peut être explicite telle que représentée par un graphique ou implicite telle qu'induite par une perturbation contradictoire.

Les signaux structurés sont couramment utilisés pour représenter des relations ou des similitudes entre des échantillons qui peuvent être étiquetés ou non. Par conséquent, l'exploitation de ces signaux lors de la formation du réseau neuronal exploite à la fois les données étiquetées et non étiquetées, ce qui peut améliorer la précision du modèle, en particulier lorsque la quantité de données étiquetées est relativement faible . De plus, les modèles entraînés avec des échantillons générés en ajoutant des perturbations contradictoires se sont révélés robustes contre les attaques malveillantes , qui sont conçues pour induire en erreur la prédiction ou la classification d'un modèle.

NSL se généralise à l'apprentissage des graphes neuronaux ainsi qu'à l'apprentissage contradictoire . Le framework NSL dans TensorFlow fournit aux développeurs les API et outils faciles à utiliser suivants pour former des modèles avec des signaux structurés :

  • API Keras pour permettre la formation avec des graphes (structure explicite) et des perturbations contradictoires (structure implicite).
  • Opérations et fonctions TF pour permettre une formation structurée lors de l'utilisation d'API TensorFlow de niveau inférieur
  • Outils pour créer des graphiques et construire des entrées de graphique pour la formation

L'incorporation de signaux structurés se fait uniquement pendant l'entraînement. Ainsi, les performances du workflow de diffusion/d'inférence restent inchangées. Vous trouverez plus d'informations sur l'apprentissage structuré neuronal dans notre description du cadre . Pour commencer, veuillez consulter notre guide d'installation , et pour une introduction pratique à NSL, consultez 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})