7 दिसंबर को महिला एमएल संगोष्ठी में भाग लें अभी पंजीकरण करें
संग्रह की मदद से व्यवस्थित रहें अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.

तंत्रिका संरचित शिक्षा: संरचित संकेतों के साथ प्रशिक्षण

न्यूरल स्ट्रक्चर्ड लर्निंग (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})