Participe do Simpósio Women in ML em 7 de dezembro Inscreva-se agora
Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Aprendizado Estruturado Neural: Treinamento com Sinais Estruturados

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

Sinais estruturados são comumente usados ​​para representar relações ou similaridade entre amostras que podem ser rotuladas ou não rotuladas. Portanto, aproveitar esses sinais durante o treinamento da rede neural aproveita dados rotulados e não rotulados, o que pode melhorar a precisão do modelo, principalmente quando a quantidade de dados rotulados é relativamente pequena . Além disso, os modelos treinados com amostras geradas pela adição de perturbação adversária demonstraram ser robustos contra ataques maliciosos , que são projetados para enganar a previsão ou classificação de um modelo.

A NSL generaliza tanto a Aprendizagem de Gráficos Neurais quanto a Aprendizagem Adversarial . A estrutura NSL no TensorFlow fornece as seguintes APIs e ferramentas fáceis de usar para os desenvolvedores treinarem modelos com sinais estruturados:

  • APIs Keras para permitir o treinamento com gráficos (estrutura explícita) e perturbações adversárias (estrutura implícita).
  • Operações e funções do TF para permitir o treinamento com estrutura ao usar APIs TensorFlow de nível inferior
  • Ferramentas para construir gráficos e construir entradas de gráficos para treinamento

A incorporação de sinais estruturados é feita apenas durante o treinamento. Portanto, o desempenho do fluxo de trabalho de veiculação/inferência permanece inalterado. Mais informações sobre aprendizagem estruturada neural podem ser encontradas na descrição do nosso framework . Para começar, consulte nosso guia de instalação e, para uma introdução prática à 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})