इस पेज का अनुवाद Cloud Translation API से किया गया है.

एसएनजीपी के साथ अनिश्चितता-जागरूक गहन शिक्षण

TensorFlow.org पर देखें

Google Colab में चलाएं

गिटहब पर देखें

नोटबुक डाउनलोड करें

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

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

यह ट्यूटोरियल दो मून्स डेटासेट पर एक गहरे अवशिष्ट नेटवर्क (ResNet)-आधारित SNGP मॉडल को लागू करता है, और इसकी अनिश्चितता की सतह की तुलना दो अन्य लोकप्रिय अनिश्चितता दृष्टिकोणों - मोंटे कार्लो ड्रॉपआउट और डीप एन्सेम्बल से करता है।

यह ट्यूटोरियल खिलौना 2D डेटासेट पर SNGP मॉडल को दिखाता है। BERT-बेस का उपयोग करके वास्तविक दुनिया की प्राकृतिक भाषा समझने के कार्य में SNGP को लागू करने के उदाहरण के लिए, कृपया SNGP-BERT ट्यूटोरियल देखें। बेंचमार्क डेटासेट (जैसे, CIFAR-100 , इमेजनेट , आरा विषाक्तता का पता लगाने , आदि) की एक विस्तृत विविधता पर SNGP मॉडल (और कई अन्य अनिश्चितता विधियों) के उच्च गुणवत्ता वाले कार्यान्वयन के लिए, कृपया अनिश्चितता बेसलाइन बेंचमार्क देखें।

एसएनजीपी के बारे में

स्पेक्ट्रल-नॉर्मलाइज्ड न्यूरल गॉसियन प्रोसेस (एसएनजीपी) एक समान स्तर की सटीकता और विलंबता को बनाए रखते हुए एक गहरी क्लासिफायरियर की अनिश्चितता गुणवत्ता में सुधार करने का एक सरल तरीका है। एक गहरे अवशिष्ट नेटवर्क को देखते हुए, SNGP मॉडल में दो साधारण परिवर्तन करता है:

यह छिपी हुई अवशिष्ट परतों के लिए वर्णक्रमीय सामान्यीकरण लागू करता है।
यह घने आउटपुट परत को गाऊसी प्रक्रिया परत से बदल देता है।

अन्य अनिश्चितता दृष्टिकोण (जैसे, मोंटे कार्लो ड्रॉपआउट या डीप पहनावा) की तुलना में, एसएनजीपी के कई फायदे हैं:

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

इस पद्धति के नुकसान हैं:

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

सेट अप

pip install --use-deprecated=legacy-resolver tf-models-official

# refresh pkg_resources so it takes the changes into account.
import pkg_resources
import importlib
importlib.reload(pkg_resources)

<module 'pkg_resources' from '/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/pkg_resources/__init__.py'>

import matplotlib.pyplot as plt
import matplotlib.colors as colors

import sklearn.datasets

import numpy as np
import tensorflow as tf

import official.nlp.modeling.layers as nlp_layers

विज़ुअलाइज़ेशन मैक्रोज़ को परिभाषित करें

plt.rcParams['figure.dpi'] = 140

DEFAULT_X_RANGE = (-3.5, 3.5)
DEFAULT_Y_RANGE = (-2.5, 2.5)
DEFAULT_CMAP = colors.ListedColormap(["#377eb8", "#ff7f00"])
DEFAULT_NORM = colors.Normalize(vmin=0, vmax=1,)
DEFAULT_N_GRID = 100

दो चाँद डेटासेट

टू मून डेटासेट से प्रशिक्षण और मूल्यांकन डेटासेट बनाएं।

def make_training_data(sample_size=500):
  """Create two moon training dataset."""
  train_examples, train_labels = sklearn.datasets.make_moons(
      n_samples=2 * sample_size, noise=0.1)

  # Adjust data position slightly.
  train_examples[train_labels == 0] += [-0.1, 0.2]
  train_examples[train_labels == 1] += [0.1, -0.2]

  return train_examples, train_labels

संपूर्ण 2D इनपुट स्थान पर मॉडल के भविष्य कहनेवाला व्यवहार का मूल्यांकन करें।

def make_testing_data(x_range=DEFAULT_X_RANGE, y_range=DEFAULT_Y_RANGE, n_grid=DEFAULT_N_GRID):
  """Create a mesh grid in 2D space."""
  # testing data (mesh grid over data space)
  x = np.linspace(x_range[0], x_range[1], n_grid)
  y = np.linspace(y_range[0], y_range[1], n_grid)
  xv, yv = np.meshgrid(x, y)
  return np.stack([xv.flatten(), yv.flatten()], axis=-1)

मॉडल अनिश्चितता का मूल्यांकन करने के लिए, एक आउट-ऑफ-डोमेन (OOD) डेटासेट जोड़ें जो किसी तृतीय श्रेणी से संबंधित हो। प्रशिक्षण के दौरान मॉडल इन OOD उदाहरणों को कभी नहीं देखता है।

def make_ood_data(sample_size=500, means=(2.5, -1.75), vars=(0.01, 0.01)):
  return np.random.multivariate_normal(
      means, cov=np.diag(vars), size=sample_size)

# Load the train, test and OOD datasets.
train_examples, train_labels = make_training_data(
    sample_size=500)
test_examples = make_testing_data()
ood_examples = make_ood_data(sample_size=500)

# Visualize
pos_examples = train_examples[train_labels == 0]
neg_examples = train_examples[train_labels == 1]

plt.figure(figsize=(7, 5.5))

plt.scatter(pos_examples[:, 0], pos_examples[:, 1], c="#377eb8", alpha=0.5)
plt.scatter(neg_examples[:, 0], neg_examples[:, 1], c="#ff7f00", alpha=0.5)
plt.scatter(ood_examples[:, 0], ood_examples[:, 1], c="red", alpha=0.1)

plt.legend(["Postive", "Negative", "Out-of-Domain"])

plt.ylim(DEFAULT_Y_RANGE)
plt.xlim(DEFAULT_X_RANGE)

plt.show()

पीएनजी

यहां नीला और नारंगी सकारात्मक और नकारात्मक वर्गों का प्रतिनिधित्व करता है, और लाल OOD डेटा का प्रतिनिधित्व करता है। एक मॉडल जो अनिश्चितता को अच्छी तरह से निर्धारित करता है, जब प्रशिक्षण डेटा के करीब (यानी, \(p(x_{test})\) 0 या 1 के करीब), और प्रशिक्षण डेटा क्षेत्रों से बहुत दूर होने पर अनिश्चित होने की उम्मीद है (यानी, \(p(x_{test})\) 0.5 के करीब) )

नियतात्मक मॉडल

मॉडल को परिभाषित करें

(बेसलाइन) नियतात्मक मॉडल से शुरू करें: ड्रॉपआउट नियमितीकरण के साथ एक बहु-परत अवशिष्ट नेटवर्क (ResNet)।

class DeepResNet(tf.keras.Model):
  """Defines a multi-layer residual network."""
  def __init__(self, num_classes, num_layers=3, num_hidden=128,
               dropout_rate=0.1, **classifier_kwargs):
    super().__init__()
    # Defines class meta data.
    self.num_hidden = num_hidden
    self.num_layers = num_layers
    self.dropout_rate = dropout_rate
    self.classifier_kwargs = classifier_kwargs

    # Defines the hidden layers.
    self.input_layer = tf.keras.layers.Dense(self.num_hidden, trainable=False)
    self.dense_layers = [self.make_dense_layer() for _ in range(num_layers)]

    # Defines the output layer.
    self.classifier = self.make_output_layer(num_classes)

  def call(self, inputs):
    # Projects the 2d input data to high dimension.
    hidden = self.input_layer(inputs)

    # Computes the resnet hidden representations.
    for i in range(self.num_layers):
      resid = self.dense_layers[i](hidden)
      resid = tf.keras.layers.Dropout(self.dropout_rate)(resid)
      hidden += resid

    return self.classifier(hidden)

  def make_dense_layer(self):
    """Uses the Dense layer as the hidden layer."""
    return tf.keras.layers.Dense(self.num_hidden, activation="relu")

  def make_output_layer(self, num_classes):
    """Uses the Dense layer as the output layer."""
    return tf.keras.layers.Dense(
        num_classes, **self.classifier_kwargs)

यह ट्यूटोरियल 128 छिपी हुई इकाइयों के साथ 6-लेयर रेसनेट का उपयोग करता है।

resnet_config = dict(num_classes=2, num_layers=6, num_hidden=128)

resnet_model = DeepResNet(**resnet_config)

resnet_model.build((None, 2))
resnet_model.summary()

Model: "deep_res_net"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 dense (Dense)               multiple                  384       
                                                                 
 dense_1 (Dense)             multiple                  16512     
                                                                 
 dense_2 (Dense)             multiple                  16512     
                                                                 
 dense_3 (Dense)             multiple                  16512     
                                                                 
 dense_4 (Dense)             multiple                  16512     
                                                                 
 dense_5 (Dense)             multiple                  16512     
                                                                 
 dense_6 (Dense)             multiple                  16512     
                                                                 
 dense_7 (Dense)             multiple                  258       
                                                                 
=================================================================
Total params: 99,714
Trainable params: 99,330
Non-trainable params: 384
_________________________________________________________________

ट्रेन मॉडल

नुकसान फ़ंक्शन और एडम ऑप्टिमाइज़र के रूप में SparseCategoricalCrossentropy का उपयोग करने के लिए प्रशिक्षण मापदंडों को कॉन्फ़िगर करें।

loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
metrics = tf.keras.metrics.SparseCategoricalAccuracy(),
optimizer = tf.keras.optimizers.Adam(learning_rate=1e-4)

train_config = dict(loss=loss, metrics=metrics, optimizer=optimizer)

बैच आकार 128 के साथ 100 युगों के लिए मॉडल को प्रशिक्षित करें।

fit_config = dict(batch_size=128, epochs=100)

resnet_model.compile(**train_config)
resnet_model.fit(train_examples, train_labels, **fit_config)

Epoch 1/100
8/8 [==============================] - 1s 4ms/step - loss: 1.1251 - sparse_categorical_accuracy: 0.5050
Epoch 2/100
8/8 [==============================] - 0s 3ms/step - loss: 0.5538 - sparse_categorical_accuracy: 0.6920
Epoch 3/100
8/8 [==============================] - 0s 3ms/step - loss: 0.2881 - sparse_categorical_accuracy: 0.9160
Epoch 4/100
8/8 [==============================] - 0s 3ms/step - loss: 0.1923 - sparse_categorical_accuracy: 0.9370
Epoch 5/100
8/8 [==============================] - 0s 3ms/step - loss: 0.1550 - sparse_categorical_accuracy: 0.9420
Epoch 6/100
8/8 [==============================] - 0s 3ms/step - loss: 0.1403 - sparse_categorical_accuracy: 0.9450
Epoch 7/100
8/8 [==============================] - 0s 3ms/step - loss: 0.1269 - sparse_categorical_accuracy: 0.9430
Epoch 8/100
8/8 [==============================] - 0s 3ms/step - loss: 0.1208 - sparse_categorical_accuracy: 0.9460
Epoch 9/100
8/8 [==============================] - 0s 3ms/step - loss: 0.1158 - sparse_categorical_accuracy: 0.9510
Epoch 10/100
8/8 [==============================] - 0s 3ms/step - loss: 0.1103 - sparse_categorical_accuracy: 0.9490
Epoch 11/100
8/8 [==============================] - 0s 3ms/step - loss: 0.1051 - sparse_categorical_accuracy: 0.9510
Epoch 12/100
8/8 [==============================] - 0s 3ms/step - loss: 0.1053 - sparse_categorical_accuracy: 0.9510
Epoch 13/100
8/8 [==============================] - 0s 3ms/step - loss: 0.1013 - sparse_categorical_accuracy: 0.9450
Epoch 14/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0967 - sparse_categorical_accuracy: 0.9500
Epoch 15/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0991 - sparse_categorical_accuracy: 0.9530
Epoch 16/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0984 - sparse_categorical_accuracy: 0.9500
Epoch 17/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0982 - sparse_categorical_accuracy: 0.9480
Epoch 18/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0918 - sparse_categorical_accuracy: 0.9510
Epoch 19/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0903 - sparse_categorical_accuracy: 0.9500
Epoch 20/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0883 - sparse_categorical_accuracy: 0.9510
Epoch 21/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0870 - sparse_categorical_accuracy: 0.9530
Epoch 22/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0884 - sparse_categorical_accuracy: 0.9560
Epoch 23/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0850 - sparse_categorical_accuracy: 0.9540
Epoch 24/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0808 - sparse_categorical_accuracy: 0.9580
Epoch 25/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0773 - sparse_categorical_accuracy: 0.9560
Epoch 26/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0801 - sparse_categorical_accuracy: 0.9590
Epoch 27/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0779 - sparse_categorical_accuracy: 0.9580
Epoch 28/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0807 - sparse_categorical_accuracy: 0.9580
Epoch 29/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0820 - sparse_categorical_accuracy: 0.9570
Epoch 30/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0730 - sparse_categorical_accuracy: 0.9600
Epoch 31/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0782 - sparse_categorical_accuracy: 0.9590
Epoch 32/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0704 - sparse_categorical_accuracy: 0.9600
Epoch 33/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0709 - sparse_categorical_accuracy: 0.9610
Epoch 34/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0758 - sparse_categorical_accuracy: 0.9580
Epoch 35/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0702 - sparse_categorical_accuracy: 0.9610
Epoch 36/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0688 - sparse_categorical_accuracy: 0.9600
Epoch 37/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0675 - sparse_categorical_accuracy: 0.9630
Epoch 38/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0636 - sparse_categorical_accuracy: 0.9690
Epoch 39/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0677 - sparse_categorical_accuracy: 0.9610
Epoch 40/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0702 - sparse_categorical_accuracy: 0.9650
Epoch 41/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0614 - sparse_categorical_accuracy: 0.9690
Epoch 42/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0663 - sparse_categorical_accuracy: 0.9680
Epoch 43/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0626 - sparse_categorical_accuracy: 0.9740
Epoch 44/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0590 - sparse_categorical_accuracy: 0.9760
Epoch 45/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0573 - sparse_categorical_accuracy: 0.9780
Epoch 46/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0568 - sparse_categorical_accuracy: 0.9770
Epoch 47/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0595 - sparse_categorical_accuracy: 0.9780
Epoch 48/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0482 - sparse_categorical_accuracy: 0.9840
Epoch 49/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0515 - sparse_categorical_accuracy: 0.9820
Epoch 50/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0525 - sparse_categorical_accuracy: 0.9830
Epoch 51/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0507 - sparse_categorical_accuracy: 0.9790
Epoch 52/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0433 - sparse_categorical_accuracy: 0.9850
Epoch 53/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0511 - sparse_categorical_accuracy: 0.9820
Epoch 54/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0501 - sparse_categorical_accuracy: 0.9820
Epoch 55/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0440 - sparse_categorical_accuracy: 0.9890
Epoch 56/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0438 - sparse_categorical_accuracy: 0.9850
Epoch 57/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0438 - sparse_categorical_accuracy: 0.9880
Epoch 58/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0416 - sparse_categorical_accuracy: 0.9860
Epoch 59/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0479 - sparse_categorical_accuracy: 0.9860
Epoch 60/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0434 - sparse_categorical_accuracy: 0.9860
Epoch 61/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0414 - sparse_categorical_accuracy: 0.9880
Epoch 62/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0402 - sparse_categorical_accuracy: 0.9870
Epoch 63/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0376 - sparse_categorical_accuracy: 0.9890
Epoch 64/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0337 - sparse_categorical_accuracy: 0.9900
Epoch 65/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0309 - sparse_categorical_accuracy: 0.9910
Epoch 66/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0336 - sparse_categorical_accuracy: 0.9910
Epoch 67/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0389 - sparse_categorical_accuracy: 0.9870
Epoch 68/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0333 - sparse_categorical_accuracy: 0.9920
Epoch 69/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0331 - sparse_categorical_accuracy: 0.9890
Epoch 70/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0346 - sparse_categorical_accuracy: 0.9900
Epoch 71/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0367 - sparse_categorical_accuracy: 0.9880
Epoch 72/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0283 - sparse_categorical_accuracy: 0.9920
Epoch 73/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0315 - sparse_categorical_accuracy: 0.9930
Epoch 74/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0271 - sparse_categorical_accuracy: 0.9900
Epoch 75/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0257 - sparse_categorical_accuracy: 0.9920
Epoch 76/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0289 - sparse_categorical_accuracy: 0.9900
Epoch 77/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0264 - sparse_categorical_accuracy: 0.9900
Epoch 78/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0272 - sparse_categorical_accuracy: 0.9910
Epoch 79/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0336 - sparse_categorical_accuracy: 0.9880
Epoch 80/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0249 - sparse_categorical_accuracy: 0.9900
Epoch 81/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0216 - sparse_categorical_accuracy: 0.9930
Epoch 82/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0279 - sparse_categorical_accuracy: 0.9890
Epoch 83/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0261 - sparse_categorical_accuracy: 0.9920
Epoch 84/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0235 - sparse_categorical_accuracy: 0.9920
Epoch 85/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0236 - sparse_categorical_accuracy: 0.9930
Epoch 86/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0219 - sparse_categorical_accuracy: 0.9920
Epoch 87/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0196 - sparse_categorical_accuracy: 0.9920
Epoch 88/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0215 - sparse_categorical_accuracy: 0.9900
Epoch 89/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0223 - sparse_categorical_accuracy: 0.9900
Epoch 90/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0200 - sparse_categorical_accuracy: 0.9950
Epoch 91/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0250 - sparse_categorical_accuracy: 0.9900
Epoch 92/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0160 - sparse_categorical_accuracy: 0.9940
Epoch 93/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0203 - sparse_categorical_accuracy: 0.9930
Epoch 94/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0203 - sparse_categorical_accuracy: 0.9930
Epoch 95/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0172 - sparse_categorical_accuracy: 0.9960
Epoch 96/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0209 - sparse_categorical_accuracy: 0.9940
Epoch 97/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0179 - sparse_categorical_accuracy: 0.9920
Epoch 98/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0195 - sparse_categorical_accuracy: 0.9940
Epoch 99/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0165 - sparse_categorical_accuracy: 0.9930
Epoch 100/100
8/8 [==============================] - 0s 3ms/step - loss: 0.0170 - sparse_categorical_accuracy: 0.9950
<keras.callbacks.History at 0x7ff7ac5c8fd0>

अनिश्चितता की कल्पना करें

def plot_uncertainty_surface(test_uncertainty, ax, cmap=None):
  """Visualizes the 2D uncertainty surface.

  For simplicity, assume these objects already exist in the memory:

    test_examples: Array of test examples, shape (num_test, 2).
    train_labels: Array of train labels, shape (num_train, ).
    train_examples: Array of train examples, shape (num_train, 2).

  Arguments:
    test_uncertainty: Array of uncertainty scores, shape (num_test,).
    ax: A matplotlib Axes object that specifies a matplotlib figure.
    cmap: A matplotlib colormap object specifying the palette of the 
      predictive surface.

  Returns:
    pcm: A matplotlib PathCollection object that contains the palette 
      information of the uncertainty plot.
  """
  # Normalize uncertainty for better visualization.
  test_uncertainty = test_uncertainty / np.max(test_uncertainty)

  # Set view limits.
  ax.set_ylim(DEFAULT_Y_RANGE)
  ax.set_xlim(DEFAULT_X_RANGE)

  # Plot normalized uncertainty surface.
  pcm = ax.imshow(
      np.reshape(test_uncertainty, [DEFAULT_N_GRID, DEFAULT_N_GRID]), 
      cmap=cmap,
      origin="lower",
      extent=DEFAULT_X_RANGE + DEFAULT_Y_RANGE,
      vmin=DEFAULT_NORM.vmin,
      vmax=DEFAULT_NORM.vmax,
      interpolation='bicubic', 
      aspect='auto')

  # Plot training data.
  ax.scatter(train_examples[:, 0], train_examples[:, 1],
             c=train_labels, cmap=DEFAULT_CMAP, alpha=0.5)
  ax.scatter(ood_examples[:, 0], ood_examples[:, 1], c="red", alpha=0.1)

  return pcm

अब नियतात्मक मॉडल की भविष्यवाणियों की कल्पना करें। पहले वर्ग की संभावना को प्लॉट करें:

\[p(x) = softmax(logit(x))\]

resnet_logits = resnet_model(test_examples)
resnet_probs = tf.nn.softmax(resnet_logits, axis=-1)[:, 0]  # Take the probability for class 0.

_, ax = plt.subplots(figsize=(7, 5.5))

pcm = plot_uncertainty_surface(resnet_probs, ax=ax)

plt.colorbar(pcm, ax=ax)
plt.title("Class Probability, Deterministic Model")

plt.show()

पीएनजी

इस भूखंड में, पीले और बैंगनी दो वर्गों के लिए भविष्य कहनेवाला संभावनाएं हैं। नियतात्मक मॉडल ने दो ज्ञात वर्गों (नीला और नारंगी) को एक गैर-रेखीय निर्णय सीमा के साथ वर्गीकृत करने में अच्छा काम किया। हालांकि, यह दूरी-जागरूक नहीं है, और कभी न देखे गए रेड आउट-ऑफ-डोमेन (OOD) उदाहरणों को आत्मविश्वास से नारंगी वर्ग के रूप में वर्गीकृत करता है।

भविष्य कहनेवाला विचरण की गणना करके मॉडल अनिश्चितता की कल्पना करें:

\[var(x) = p(x) * (1 - p(x))\]

resnet_uncertainty = resnet_probs * (1 - resnet_probs)

_, ax = plt.subplots(figsize=(7, 5.5))

pcm = plot_uncertainty_surface(resnet_uncertainty, ax=ax)

plt.colorbar(pcm, ax=ax)
plt.title("Predictive Uncertainty, Deterministic Model")

plt.show()

पीएनजी

इस भूखंड में, पीला उच्च अनिश्चितता को इंगित करता है, और बैंगनी कम अनिश्चितता को इंगित करता है। नियतात्मक ResNet की अनिश्चितता केवल परीक्षण उदाहरणों की निर्णय सीमा से दूरी पर निर्भर करती है। यह प्रशिक्षण डोमेन से बाहर होने पर मॉडल को अति-आत्मविश्वास की ओर ले जाता है। अगला खंड दिखाता है कि एसएनजीपी इस डेटासेट पर अलग तरह से कैसे व्यवहार करता है।

एसएनजीपी मॉडल

एसएनजीपी मॉडल को परिभाषित करें

आइए अब एसएनजीपी मॉडल लागू करें। दोनों SNGP घटक, SpectralNormalization और RandomFeatureGaussianProcess , tensorflow_model की अंतर्निर्मित परतों पर उपलब्ध हैं।

आइए इन दो घटकों को अधिक विस्तार से देखें। (पूर्ण मॉडल को कैसे लागू किया जाता है, यह देखने के लिए आप एसएनजीपी मॉडल अनुभाग पर भी जा सकते हैं।)

वर्णक्रमीय सामान्यीकरण आवरण

SpectralNormalization सामान्यीकरण एक केरस परत आवरण है। इसे मौजूदा Dense लेयर पर इस तरह लागू किया जा सकता है:

dense = tf.keras.layers.Dense(units=10)
dense = nlp_layers.SpectralNormalization(dense, norm_multiplier=0.9)

वर्णक्रमीय सामान्यीकरण छिपे हुए भार \(W\) को धीरे-धीरे इसके वर्णक्रमीय मानदंड (यानी, \(W\)का सबसे बड़ा eigenvalue) को लक्ष्य मान norm_multiplier की ओर निर्देशित करके नियमित करता है।

गाऊसी प्रक्रिया (जीपी) परत

RandomFeatureGaussianProcess एक गाऊसी प्रक्रिया मॉडल के लिए एक यादृच्छिक-सुविधा आधारित सन्निकटन लागू करता है जो एक गहरे तंत्रिका नेटवर्क के साथ एंड-टू-एंड प्रशिक्षण योग्य है। हुड के तहत, गाऊसी प्रक्रिया परत दो-परत नेटवर्क को लागू करती है:

\[logits(x) = \Phi(x) \beta, \quad \Phi(x)=\sqrt{\frac{2}{M} } * cos(Wx + b)\]

यहाँ \(x\) इनपुट है, और \(W\) और \(b\) क्रमशः गाऊसी और समान वितरण से बेतरतीब ढंग से आरंभ किए गए जमे हुए वजन हैं। (इसलिए \(\Phi(x)\) को "यादृच्छिक विशेषताएं" कहा जाता है।) \(\beta\) एक सघन परत के समान सीखने योग्य कर्नेल भार है।

batch_size = 32
input_dim = 1024
num_classes = 10

gp_layer = nlp_layers.RandomFeatureGaussianProcess(units=num_classes,
                                               num_inducing=1024,
                                               normalize_input=False,
                                               scale_random_features=True,
                                               gp_cov_momentum=-1)

जीपी परतों के मुख्य पैरामीटर हैं:

units : आउटपुट का आयाम लॉग करता है।
num_inducing : छिपे हुए भार का आयाम \(M\) \(W\)। 1024 के लिए डिफ़ॉल्ट।
normalize_input : इनपुट \(x\)पर लेयर नॉर्मलाइजेशन लागू करना है या नहीं।
scale_random_features : क्या स्केल l10n- \(\sqrt{2/M}\) 16 को हिडन आउटपुट पर लागू करना है।

नोट: एक गहरे तंत्रिका नेटवर्क के लिए जो सीखने की दर के प्रति संवेदनशील है (उदाहरण के लिए, ResNet-50 और ResNet-110), सामान्य रूप से प्रशिक्षण को स्थिर करने के लिए normalize_input=True सेट करने की अनुशंसा की जाती है, और सीखने की दर से बचने के लिए scale_random_features=False सेट करने की अनुशंसा की जाती है। जीपी परत से गुजरते समय अप्रत्याशित तरीके से संशोधित किया जा रहा है।

gp_cov_momentum नियंत्रित करता है कि मॉडल सहप्रसरण की गणना कैसे की जाती है। यदि एक सकारात्मक मान (जैसे, 0.999) पर सेट किया जाता है, तो कॉन्वर्सिस मैट्रिक्स की गणना गति-आधारित चलती औसत अद्यतन (बैच सामान्यीकरण के समान) का उपयोग करके की जाती है। यदि -1 पर सेट किया जाता है, तो कॉन्वर्सिस मैट्रिक्स बिना संवेग के अद्यतन किया जाता है।

नोट: गति-आधारित अद्यतन विधि बैच आकार के प्रति संवेदनशील हो सकती है। इसलिए सामान्यतः सहप्रसरण की सटीक गणना करने के लिए gp_cov_momentum=-1 सेट करने की अनुशंसा की जाती है। इसके लिए ठीक से काम करने के लिए, एक ही डेटा को दो बार गिनने से बचने के लिए कॉन्वर्सिस मैट्रिक्स अनुमानक को एक नए युग की शुरुआत में रीसेट करने की आवश्यकता होती है। RandomFeatureGaussianProcess के लिए, यह इसके reset_covariance_matrix() पर कॉल करके किया जा सकता है। अगला खंड केरस के अंतर्निहित एपीआई का उपयोग करके इसका आसान कार्यान्वयन दिखाता है।

आकार (batch_size, input_dim) के साथ एक बैच इनपुट को देखते हुए, जीपी परत भविष्यवाणी के लिए एक logits टेंसर (आकृति (batch_size, num_classes) ) देता है, और covmat टेंसर (आकार (batch_size, batch_size) बैच_साइज़, बैच_साइज़)) भी देता है, जो कि पोस्टीरियर कॉन्वर्सिस मैट्रिक्स है। बैच लॉग।

embedding = tf.random.normal(shape=(batch_size, input_dim))

logits, covmat = gp_layer(embedding)

सैद्धांतिक रूप से, विभिन्न वर्गों के लिए अलग-अलग भिन्नता मूल्यों की गणना करने के लिए एल्गोरिदम का विस्तार करना संभव है (जैसा कि मूल एसएनजीपी पेपर में पेश किया गया है)। हालांकि, बड़े आउटपुट स्पेस (जैसे, इमेजनेट या भाषा मॉडलिंग) के साथ समस्याओं को मापना मुश्किल है।

पूर्ण SNGP मॉडल

बेस क्लास DeepResNet को देखते हुए, एसएनजीपी मॉडल को अवशिष्ट नेटवर्क की छिपी और आउटपुट परतों को संशोधित करके आसानी से लागू किया जा सकता है। model.fit() एपीआई के साथ संगतता के लिए, मॉडल की call() विधि को भी संशोधित करें ताकि यह केवल प्रशिक्षण के दौरान logits को आउटपुट करे।

class DeepResNetSNGP(DeepResNet):
  def __init__(self, spec_norm_bound=0.9, **kwargs):
    self.spec_norm_bound = spec_norm_bound
    super().__init__(**kwargs)

  def make_dense_layer(self):
    """Applies spectral normalization to the hidden layer."""
    dense_layer = super().make_dense_layer()
    return nlp_layers.SpectralNormalization(
        dense_layer, norm_multiplier=self.spec_norm_bound)

  def make_output_layer(self, num_classes):
    """Uses Gaussian process as the output layer."""
    return nlp_layers.RandomFeatureGaussianProcess(
        num_classes, 
        gp_cov_momentum=-1,
        **self.classifier_kwargs)

  def call(self, inputs, training=False, return_covmat=False):
    # Gets logits and covariance matrix from GP layer.
    logits, covmat = super().call(inputs)

    # Returns only logits during training.
    if not training and return_covmat:
      return logits, covmat

    return logits

नियतात्मक मॉडल के समान वास्तुकला का उपयोग करें।

resnet_config

{'num_classes': 2, 'num_layers': 6, 'num_hidden': 128}

sngp_model = DeepResNetSNGP(**resnet_config)

sngp_model.build((None, 2))
sngp_model.summary()

Model: "deep_res_net_sngp"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 dense_9 (Dense)             multiple                  384       
                                                                 
 spectral_normalization_1 (S  multiple                 16768     
 pectralNormalization)                                           
                                                                 
 spectral_normalization_2 (S  multiple                 16768     
 pectralNormalization)                                           
                                                                 
 spectral_normalization_3 (S  multiple                 16768     
 pectralNormalization)                                           
                                                                 
 spectral_normalization_4 (S  multiple                 16768     
 pectralNormalization)                                           
                                                                 
 spectral_normalization_5 (S  multiple                 16768     
 pectralNormalization)                                           
                                                                 
 spectral_normalization_6 (S  multiple                 16768     
 pectralNormalization)                                           
                                                                 
 random_feature_gaussian_pro  multiple                 1182722   
 cess (RandomFeatureGaussian                                     
 Process)                                                        
                                                                 
=================================================================
Total params: 1,283,714
Trainable params: 101,120
Non-trainable params: 1,182,594
_________________________________________________________________

एक नए युग की शुरुआत में सहप्रसरण मैट्रिक्स को रीसेट करने के लिए एक केरस कॉलबैक लागू करें।

class ResetCovarianceCallback(tf.keras.callbacks.Callback):

  def on_epoch_begin(self, epoch, logs=None):
    """Resets covariance matrix at the begining of the epoch."""
    if epoch > 0:
      self.model.classifier.reset_covariance_matrix()

इस कॉलबैक को DeepResNetSNGP मॉडल क्लास में जोड़ें।

class DeepResNetSNGPWithCovReset(DeepResNetSNGP):
  def fit(self, *args, **kwargs):
    """Adds ResetCovarianceCallback to model callbacks."""
    kwargs["callbacks"] = list(kwargs.get("callbacks", []))
    kwargs["callbacks"].append(ResetCovarianceCallback())

    return super().fit(*args, **kwargs)

ट्रेन मॉडल

मॉडल को प्रशिक्षित करने के लिए tf.keras.model.fit का उपयोग करें।

sngp_model = DeepResNetSNGPWithCovReset(**resnet_config)
sngp_model.compile(**train_config)
sngp_model.fit(train_examples, train_labels, **fit_config)

Epoch 1/100
8/8 [==============================] - 2s 5ms/step - loss: 0.6223 - sparse_categorical_accuracy: 0.9570
Epoch 2/100
8/8 [==============================] - 0s 4ms/step - loss: 0.5310 - sparse_categorical_accuracy: 0.9980
Epoch 3/100
8/8 [==============================] - 0s 4ms/step - loss: 0.4766 - sparse_categorical_accuracy: 0.9990
Epoch 4/100
8/8 [==============================] - 0s 5ms/step - loss: 0.4346 - sparse_categorical_accuracy: 0.9980
Epoch 5/100
8/8 [==============================] - 0s 5ms/step - loss: 0.4015 - sparse_categorical_accuracy: 0.9980
Epoch 6/100
8/8 [==============================] - 0s 5ms/step - loss: 0.3757 - sparse_categorical_accuracy: 0.9990
Epoch 7/100
8/8 [==============================] - 0s 4ms/step - loss: 0.3525 - sparse_categorical_accuracy: 0.9990
Epoch 8/100
8/8 [==============================] - 0s 4ms/step - loss: 0.3305 - sparse_categorical_accuracy: 0.9990
Epoch 9/100
8/8 [==============================] - 0s 5ms/step - loss: 0.3144 - sparse_categorical_accuracy: 0.9980
Epoch 10/100
8/8 [==============================] - 0s 5ms/step - loss: 0.2975 - sparse_categorical_accuracy: 0.9990
Epoch 11/100
8/8 [==============================] - 0s 4ms/step - loss: 0.2832 - sparse_categorical_accuracy: 0.9990
Epoch 12/100
8/8 [==============================] - 0s 5ms/step - loss: 0.2707 - sparse_categorical_accuracy: 0.9990
Epoch 13/100
8/8 [==============================] - 0s 4ms/step - loss: 0.2568 - sparse_categorical_accuracy: 0.9990
Epoch 14/100
8/8 [==============================] - 0s 4ms/step - loss: 0.2470 - sparse_categorical_accuracy: 0.9970
Epoch 15/100
8/8 [==============================] - 0s 4ms/step - loss: 0.2361 - sparse_categorical_accuracy: 0.9990
Epoch 16/100
8/8 [==============================] - 0s 5ms/step - loss: 0.2271 - sparse_categorical_accuracy: 0.9990
Epoch 17/100
8/8 [==============================] - 0s 5ms/step - loss: 0.2182 - sparse_categorical_accuracy: 0.9990
Epoch 18/100
8/8 [==============================] - 0s 4ms/step - loss: 0.2097 - sparse_categorical_accuracy: 0.9990
Epoch 19/100
8/8 [==============================] - 0s 4ms/step - loss: 0.2018 - sparse_categorical_accuracy: 0.9990
Epoch 20/100
8/8 [==============================] - 0s 4ms/step - loss: 0.1940 - sparse_categorical_accuracy: 0.9980
Epoch 21/100
8/8 [==============================] - 0s 4ms/step - loss: 0.1892 - sparse_categorical_accuracy: 0.9990
Epoch 22/100
8/8 [==============================] - 0s 4ms/step - loss: 0.1821 - sparse_categorical_accuracy: 0.9980
Epoch 23/100
8/8 [==============================] - 0s 4ms/step - loss: 0.1768 - sparse_categorical_accuracy: 0.9990
Epoch 24/100
8/8 [==============================] - 0s 4ms/step - loss: 0.1702 - sparse_categorical_accuracy: 0.9980
Epoch 25/100
8/8 [==============================] - 0s 4ms/step - loss: 0.1664 - sparse_categorical_accuracy: 0.9990
Epoch 26/100
8/8 [==============================] - 0s 4ms/step - loss: 0.1604 - sparse_categorical_accuracy: 0.9990
Epoch 27/100
8/8 [==============================] - 0s 4ms/step - loss: 0.1565 - sparse_categorical_accuracy: 0.9990
Epoch 28/100
8/8 [==============================] - 0s 4ms/step - loss: 0.1517 - sparse_categorical_accuracy: 0.9990
Epoch 29/100
8/8 [==============================] - 0s 4ms/step - loss: 0.1469 - sparse_categorical_accuracy: 0.9990
Epoch 30/100
8/8 [==============================] - 0s 4ms/step - loss: 0.1431 - sparse_categorical_accuracy: 0.9980
Epoch 31/100
8/8 [==============================] - 0s 4ms/step - loss: 0.1385 - sparse_categorical_accuracy: 0.9980
Epoch 32/100
8/8 [==============================] - 0s 4ms/step - loss: 0.1351 - sparse_categorical_accuracy: 0.9990
Epoch 33/100
8/8 [==============================] - 0s 5ms/step - loss: 0.1312 - sparse_categorical_accuracy: 0.9980
Epoch 34/100
8/8 [==============================] - 0s 4ms/step - loss: 0.1289 - sparse_categorical_accuracy: 0.9990
Epoch 35/100
8/8 [==============================] - 0s 4ms/step - loss: 0.1254 - sparse_categorical_accuracy: 0.9980
Epoch 36/100
8/8 [==============================] - 0s 4ms/step - loss: 0.1223 - sparse_categorical_accuracy: 0.9980
Epoch 37/100
8/8 [==============================] - 0s 4ms/step - loss: 0.1180 - sparse_categorical_accuracy: 0.9990
Epoch 38/100
8/8 [==============================] - 0s 4ms/step - loss: 0.1167 - sparse_categorical_accuracy: 0.9990
Epoch 39/100
8/8 [==============================] - 0s 4ms/step - loss: 0.1132 - sparse_categorical_accuracy: 0.9980
Epoch 40/100
8/8 [==============================] - 0s 4ms/step - loss: 0.1110 - sparse_categorical_accuracy: 0.9990
Epoch 41/100
8/8 [==============================] - 0s 4ms/step - loss: 0.1075 - sparse_categorical_accuracy: 0.9990
Epoch 42/100
8/8 [==============================] - 0s 4ms/step - loss: 0.1067 - sparse_categorical_accuracy: 0.9990
Epoch 43/100
8/8 [==============================] - 0s 4ms/step - loss: 0.1034 - sparse_categorical_accuracy: 0.9990
Epoch 44/100
8/8 [==============================] - 0s 4ms/step - loss: 0.1006 - sparse_categorical_accuracy: 0.9990
Epoch 45/100
8/8 [==============================] - 0s 5ms/step - loss: 0.0991 - sparse_categorical_accuracy: 0.9990
Epoch 46/100
8/8 [==============================] - 0s 5ms/step - loss: 0.0963 - sparse_categorical_accuracy: 0.9990
Epoch 47/100
8/8 [==============================] - 0s 5ms/step - loss: 0.0943 - sparse_categorical_accuracy: 0.9980
Epoch 48/100
8/8 [==============================] - 0s 5ms/step - loss: 0.0925 - sparse_categorical_accuracy: 0.9990
Epoch 49/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0905 - sparse_categorical_accuracy: 0.9990
Epoch 50/100
8/8 [==============================] - 0s 5ms/step - loss: 0.0889 - sparse_categorical_accuracy: 0.9990
Epoch 51/100
8/8 [==============================] - 0s 5ms/step - loss: 0.0863 - sparse_categorical_accuracy: 0.9980
Epoch 52/100
8/8 [==============================] - 0s 5ms/step - loss: 0.0847 - sparse_categorical_accuracy: 0.9990
Epoch 53/100
8/8 [==============================] - 0s 5ms/step - loss: 0.0831 - sparse_categorical_accuracy: 0.9980
Epoch 54/100
8/8 [==============================] - 0s 5ms/step - loss: 0.0818 - sparse_categorical_accuracy: 0.9990
Epoch 55/100
8/8 [==============================] - 0s 5ms/step - loss: 0.0799 - sparse_categorical_accuracy: 0.9990
Epoch 56/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0780 - sparse_categorical_accuracy: 0.9990
Epoch 57/100
8/8 [==============================] - 0s 5ms/step - loss: 0.0768 - sparse_categorical_accuracy: 0.9990
Epoch 58/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0751 - sparse_categorical_accuracy: 0.9990
Epoch 59/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0748 - sparse_categorical_accuracy: 0.9990
Epoch 60/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0723 - sparse_categorical_accuracy: 0.9990
Epoch 61/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0712 - sparse_categorical_accuracy: 0.9990
Epoch 62/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0701 - sparse_categorical_accuracy: 0.9990
Epoch 63/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0701 - sparse_categorical_accuracy: 0.9990
Epoch 64/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0683 - sparse_categorical_accuracy: 0.9990
Epoch 65/100
8/8 [==============================] - 0s 5ms/step - loss: 0.0665 - sparse_categorical_accuracy: 0.9990
Epoch 66/100
8/8 [==============================] - 0s 5ms/step - loss: 0.0661 - sparse_categorical_accuracy: 0.9990
Epoch 67/100
8/8 [==============================] - 0s 5ms/step - loss: 0.0636 - sparse_categorical_accuracy: 0.9990
Epoch 68/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0631 - sparse_categorical_accuracy: 0.9990
Epoch 69/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0620 - sparse_categorical_accuracy: 0.9990
Epoch 70/100
8/8 [==============================] - 0s 5ms/step - loss: 0.0606 - sparse_categorical_accuracy: 0.9990
Epoch 71/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0601 - sparse_categorical_accuracy: 0.9980
Epoch 72/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0590 - sparse_categorical_accuracy: 0.9990
Epoch 73/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0586 - sparse_categorical_accuracy: 0.9990
Epoch 74/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0574 - sparse_categorical_accuracy: 0.9990
Epoch 75/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0565 - sparse_categorical_accuracy: 1.0000
Epoch 76/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0559 - sparse_categorical_accuracy: 0.9990
Epoch 77/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0549 - sparse_categorical_accuracy: 0.9990
Epoch 78/100
8/8 [==============================] - 0s 5ms/step - loss: 0.0534 - sparse_categorical_accuracy: 1.0000
Epoch 79/100
8/8 [==============================] - 0s 5ms/step - loss: 0.0532 - sparse_categorical_accuracy: 0.9990
Epoch 80/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0519 - sparse_categorical_accuracy: 1.0000
Epoch 81/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0511 - sparse_categorical_accuracy: 1.0000
Epoch 82/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0508 - sparse_categorical_accuracy: 0.9990
Epoch 83/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0499 - sparse_categorical_accuracy: 1.0000
Epoch 84/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0490 - sparse_categorical_accuracy: 1.0000
Epoch 85/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0490 - sparse_categorical_accuracy: 0.9990
Epoch 86/100
8/8 [==============================] - 0s 5ms/step - loss: 0.0470 - sparse_categorical_accuracy: 1.0000
Epoch 87/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0468 - sparse_categorical_accuracy: 1.0000
Epoch 88/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0468 - sparse_categorical_accuracy: 1.0000
Epoch 89/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0453 - sparse_categorical_accuracy: 1.0000
Epoch 90/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0448 - sparse_categorical_accuracy: 1.0000
Epoch 91/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0441 - sparse_categorical_accuracy: 1.0000
Epoch 92/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0434 - sparse_categorical_accuracy: 1.0000
Epoch 93/100
8/8 [==============================] - 0s 5ms/step - loss: 0.0431 - sparse_categorical_accuracy: 1.0000
Epoch 94/100
8/8 [==============================] - 0s 5ms/step - loss: 0.0424 - sparse_categorical_accuracy: 1.0000
Epoch 95/100
8/8 [==============================] - 0s 5ms/step - loss: 0.0420 - sparse_categorical_accuracy: 1.0000
Epoch 96/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0415 - sparse_categorical_accuracy: 1.0000
Epoch 97/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0409 - sparse_categorical_accuracy: 1.0000
Epoch 98/100
8/8 [==============================] - 0s 4ms/step - loss: 0.0401 - sparse_categorical_accuracy: 1.0000
Epoch 99/100
8/8 [==============================] - 0s 5ms/step - loss: 0.0396 - sparse_categorical_accuracy: 1.0000
Epoch 100/100
8/8 [==============================] - 0s 5ms/step - loss: 0.0392 - sparse_categorical_accuracy: 1.0000
<keras.callbacks.History at 0x7ff7ac0f83d0>

अनिश्चितता की कल्पना करें

पहले भविष्य कहनेवाला लॉग और प्रसरण की गणना करें।

sngp_logits, sngp_covmat = sngp_model(test_examples, return_covmat=True)

sngp_variance = tf.linalg.diag_part(sngp_covmat)[:, None]

अब पश्चवर्ती भविष्य कहनेवाला संभाव्यता की गणना करें। एक संभाव्य मॉडल की भविष्य कहनेवाला संभावना की गणना के लिए क्लासिक विधि मोंटे कार्लो नमूनाकरण का उपयोग करना है, अर्थात,

\[E(p(x)) = \frac{1}{M} \sum_{m=1}^M logit_m(x), \]

जहां \(M\) नमूना आकार है, और \(logit_m(x)\) SNGP पोस्टीरियर l10n- \(MultivariateNormal\)23 ( sngp_logits , sngp_covmat ) से यादृच्छिक नमूने हैं। हालांकि, स्वायत्त ड्राइविंग या रीयल-टाइम बोली-प्रक्रिया जैसे विलंबता-संवेदनशील अनुप्रयोगों के लिए यह दृष्टिकोण धीमा हो सकता है। इसके बजाय, माध्य-फ़ील्ड विधि का उपयोग करके \(E(p(x))\) का अनुमान लगा सकते हैं:

\[E(p(x)) \approx softmax(\frac{logit(x)}{\sqrt{1+ \lambda * \sigma^2(x)} })\]

जहां \(\sigma^2(x)\) SNGP विचरण है, और \(\lambda\) को अक्सर \(\pi/8\) या \(3/\pi^2\)के रूप में चुना जाता है।

sngp_logits_adjusted = sngp_logits / tf.sqrt(1. + (np.pi / 8.) * sngp_variance)
sngp_probs = tf.nn.softmax(sngp_logits_adjusted, axis=-1)[:, 0]

यह माध्य-क्षेत्र विधि एक अंतर्निहित फ़ंक्शन के रूप में कार्यान्वित की जाती है layers.gaussian_process.mean_field_logits :

def compute_posterior_mean_probability(logits, covmat, lambda_param=np.pi / 8.):
  # Computes uncertainty-adjusted logits using the built-in method.
  logits_adjusted = nlp_layers.gaussian_process.mean_field_logits(
      logits, covmat, mean_field_factor=lambda_param)

  return tf.nn.softmax(logits_adjusted, axis=-1)[:, 0]

sngp_logits, sngp_covmat = sngp_model(test_examples, return_covmat=True)
sngp_probs = compute_posterior_mean_probability(sngp_logits, sngp_covmat)

एसएनजीपी सारांश

def plot_predictions(pred_probs, model_name=""):
  """Plot normalized class probabilities and predictive uncertainties."""
  # Compute predictive uncertainty.
  uncertainty = pred_probs * (1. - pred_probs)

  # Initialize the plot axes.
  fig, axs = plt.subplots(1, 2, figsize=(14, 5))

  # Plots the class probability.
  pcm_0 = plot_uncertainty_surface(pred_probs, ax=axs[0])
  # Plots the predictive uncertainty.
  pcm_1 = plot_uncertainty_surface(uncertainty, ax=axs[1])

  # Adds color bars and titles.
  fig.colorbar(pcm_0, ax=axs[0])
  fig.colorbar(pcm_1, ax=axs[1])

  axs[0].set_title(f"Class Probability, {model_name}")
  axs[1].set_title(f"(Normalized) Predictive Uncertainty, {model_name}")

  plt.show()

सब कुछ एक साथ रखो। पूरी प्रक्रिया (प्रशिक्षण, मूल्यांकन और अनिश्चितता की गणना) सिर्फ पांच पंक्तियों में की जा सकती है:

def train_and_test_sngp(train_examples, test_examples):
  sngp_model = DeepResNetSNGPWithCovReset(**resnet_config)

  sngp_model.compile(**train_config)
  sngp_model.fit(train_examples, train_labels, verbose=0, **fit_config)

  sngp_logits, sngp_covmat = sngp_model(test_examples, return_covmat=True)
  sngp_probs = compute_posterior_mean_probability(sngp_logits, sngp_covmat)

  return sngp_probs

sngp_probs = train_and_test_sngp(train_examples, test_examples)

एसएनजीपी मॉडल की वर्ग संभावना (बाएं) और भविष्य कहनेवाला अनिश्चितता (दाएं) की कल्पना करें।

plot_predictions(sngp_probs, model_name="SNGP")

पीएनजी

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

इसकी तुलना नियतात्मक मॉडल की अनिश्चितता सतह से करें:

plot_predictions(resnet_probs, model_name="Deterministic")

पीएनजी

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

अन्य अनिश्चितता दृष्टिकोणों के साथ तुलना

यह खंड एसएनजीपी की अनिश्चितता की तुलना मोंटे कार्लो ड्रॉपआउट और डीप एसेम्बल से करता है।

ये दोनों तरीके मोंटे कार्लो पर आधारित हैं, जो नियतात्मक मॉडल के कई फॉरवर्ड पास के औसत हैं। पहले पहनावा आकार \(M\)सेट करें।

num_ensemble = 10

मोंटे कार्लो ड्रॉपआउट

ड्रॉपआउट परतों के साथ एक प्रशिक्षित तंत्रिका नेटवर्क को देखते हुए, मोंटे कार्लो ड्रॉपआउट औसत भविष्य कहनेवाला संभावना की गणना करता है

\[E(p(x)) = \frac{1}{M}\sum_{m=1}^M softmax(logit_m(x))\]

एकाधिक ड्रॉपआउट-सक्षम फॉरवर्ड पास \(\{logit_m(x)\}_{m=1}^M\)पर औसत से।

def mc_dropout_sampling(test_examples):
  # Enable dropout during inference.
  return resnet_model(test_examples, training=True)

# Monte Carlo dropout inference.
dropout_logit_samples = [mc_dropout_sampling(test_examples) for _ in range(num_ensemble)]
dropout_prob_samples = [tf.nn.softmax(dropout_logits, axis=-1)[:, 0] for dropout_logits in dropout_logit_samples]
dropout_probs = tf.reduce_mean(dropout_prob_samples, axis=0)

dropout_probs = tf.reduce_mean(dropout_prob_samples, axis=0)

plot_predictions(dropout_probs, model_name="MC Dropout")

पीएनजी

गहरा पहनावा

गहन शिक्षण अनिश्चितता के लिए डीप एसेम्बल एक अत्याधुनिक (लेकिन महंगी) विधि है। एक डीप पहनावा को प्रशिक्षित करने के लिए, पहले \(M\) कलाकारों की टुकड़ी को प्रशिक्षित करें।

# Deep ensemble training
resnet_ensemble = []
for _ in range(num_ensemble):
  resnet_model = DeepResNet(**resnet_config)
  resnet_model.compile(optimizer=optimizer, loss=loss, metrics=metrics)
  resnet_model.fit(train_examples, train_labels, verbose=0, **fit_config)  

  resnet_ensemble.append(resnet_model)

लघुगणक एकत्र करें और माध्य पूर्वानुमानित प्रायिकता \(E(p(x)) = \frac{1}{M}\sum_{m=1}^M softmax(logit_m(x))\)परिकलित करें।

# Deep ensemble inference
ensemble_logit_samples = [model(test_examples) for model in resnet_ensemble]
ensemble_prob_samples = [tf.nn.softmax(logits, axis=-1)[:, 0] for logits in ensemble_logit_samples]
ensemble_probs = tf.reduce_mean(ensemble_prob_samples, axis=0)

plot_predictions(ensemble_probs, model_name="Deep ensemble")

पीएनजी

MC ड्रॉपआउट और डीप पहनावा दोनों निर्णय सीमा को कम निश्चित करके एक मॉडल की अनिश्चितता क्षमता में सुधार करते हैं। हालांकि, वे दोनों दूरी जागरूकता की कमी में नियतात्मक गहरे नेटवर्क की सीमा को प्राप्त करते हैं।

सारांश

इस ट्यूटोरियल में, आपके पास है:

अपनी दूरी जागरूकता में सुधार के लिए एक डीप क्लासिफायर पर एक एसएनजीपी मॉडल लागू किया।
model.fit() एपीआई का उपयोग करके एसएनजीपी मॉडल को एंड-टू-एंड प्रशिक्षित किया।
SNGP के अनिश्चितता व्यवहार की कल्पना की।
एसएनजीपी, मोंटे कार्लो ड्रॉपआउट और गहरे पहनावा मॉडल के बीच अनिश्चितता के व्यवहार की तुलना।

संसाधन और आगे पढ़ना

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