O Google I / O retorna de 18 a 20 de maio! Reserve espaço e monte sua agenda Cadastre-se agora

Neural Structured Learning: treinamento com sinais estruturados

O Neural Structured Learning (NSL) é um novo paradigma de aprendizado para treinar redes neurais usando sinais estruturados e entradas de recursos. A estrutura pode ser explícita, como representada em um grafo ou implícita, como induzida por perturbação adversária.

Sinais estruturados são comumente usados para representar relações ou semelhanças entre amostras que podem ser rotuladas ou não. Portanto, ao usar esses sinais durante o treinamento da rede neural, os dados rotulados e não rotulados são aproveitados. Isso que pode melhorar a precisão do modelo, especialmente quando a quantidade de dados rotulados é relativamente pequena. Além disso, os modelos treinados com amostras geradas por meio da adição de perturbação adversária foram mostrados como robustos contra ataques mal-intencionados, que são projetados para enganar a previsão ou classificação de um modelo.

O NSL generaliza o aprendizado de grafos neurais e o aprendizado adversário. O framework NSL no TensorFlow fornece as seguintes APIs e ferramentas fáceis de usar para que os desenvolvedores treinem modelos com sinais estruturados:

  • APIs Keras para ativar o treinamento com grafos (estrutura explícita) e perturbações adversárias (estrutura implícita).
  • Ops e funções do TF para ativar o treinamento com estrutura ao usar APIs de nível inferior do TensorFlow
  • Ferramentas para criar grafos e entradas de grafos para treinamento

A incorporação de sinais estruturados é feita apenas durante o treinamento. Assim, o desempenho do fluxo de trabalho exibição/inferência permanece inalterado. Mais informações sobre Neural Structured Learning podem ser encontradas na descrição do framework. Para começar, consulte o guia de instalação. Para uma introdução prática a NSL, confira nossos tutoriais.

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