न्यूरल स्ट्रक्चर्ड लर्निंग: स्ट्रक्चर्ड सिग्नल के साथ प्रशिक्षण

न्यूरल स्ट्रक्चर्ड लर्निंग (NSL) फीचर इनपुट्स के अलावा स्ट्रक्चर्ड सिग्नल का उपयोग करके न्यूरल नेटवर्क को प्रशिक्षित करने के लिए एक नया लर्निंग पैराडाइम है। संरचना को ग्राफ के रूप में दर्शाया जा सकता है या प्रतिकूल प्रतिरूपण द्वारा प्रेरित किया जा सकता है।

संरचित संकेतों का उपयोग आमतौर पर उन नमूनों के बीच संबंधों या समानता का प्रतिनिधित्व करने के लिए किया जाता है जिन्हें लेबल या लेबल नहीं किया जा सकता है। इसलिए, तंत्रिका नेटवर्क प्रशिक्षण के दौरान इन संकेतों का लाभ उठाने से लेबल और अनबेल्ड डेटा दोनों का उपयोग होता है, जो मॉडल सटीकता में सुधार कर सकता है, खासकर जब लेबल डेटा की मात्रा अपेक्षाकृत कम होती है । इसके अतिरिक्त, नमूनों के साथ प्रशिक्षित मॉडल जो प्रतिकूल पेरिस्टर्बेशन जोड़कर उत्पन्न होते हैं, उन्हें दुर्भावनापूर्ण हमलों के खिलाफ मजबूत दिखाया गया है, जो एक मॉडल की भविष्यवाणी या वर्गीकरण को भ्रमित करने के लिए डिज़ाइन किए गए हैं।

NSL तंत्रिका ग्राफ़ लर्निंग के साथ-साथ एडवांसरियल लर्निंग का सामान्यीकरण करता है। TensorFlow में NSL फ्रेमवर्क संरचित के साथ मॉडल को प्रशिक्षित करने के लिए डेवलपर्स के लिए निम्नलिखित आसान एपीआई और उपकरण प्रदान करता है:

  • ग्राफ़ (स्पष्ट संरचना) और प्रतिकूल गड़बड़ी (अंतर्निहित संरचना) के साथ प्रशिक्षण को सक्षम करने के लिए केरस एपीआई
  • निम्न-स्तरीय TensorFlow API का उपयोग करते समय संरचना के साथ प्रशिक्षण को सक्षम करने के लिए TF ऑप्स और फ़ंक्शन
  • प्रशिक्षण के लिए ग्राफ़ बनाने और ग्राफ़ इनपुट बनाने के लिए उपकरण

प्रशिक्षण के दौरान ही संरचित संकेतों को शामिल किया जाता है। इसलिए, सेवारत / अनुमान वर्कफ़्लो का प्रदर्शन अपरिवर्तित रहता है। तंत्रिका संरचित सीखने पर अधिक जानकारी हमारे रूपरेखा विवरण में पाई जा सकती है। आरंभ करने के लिए, कृपया हमारे इंस्टॉल गाइड और एनएसएल के व्यावहारिक परिचय के लिए, हमारे ट्यूटोरियल देखें।

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