BERT-SNGP के साथ अनिश्चितता-जागरूक गहरी भाषा सीखना

TensorFlow.org पर देखें Google Colab में चलाएं गिटहब पर देखें नोटबुक डाउनलोड करें टीएफ हब मॉडल देखें

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

विशेष रूप से, आप करेंगे:

  • BERT-SNGP, एक SNGP-संवर्धित BERT मॉडल बनाएँ।
  • CLINC आउट-ऑफ-स्कोप (OOS) इंटेंट डिटेक्शन डेटासेट लोड करें।
  • BERT-SNGP मॉडल को प्रशिक्षित करें।
  • अनिश्चितता अंशांकन और आउट-ऑफ-डोमेन डिटेक्शन में BERT-SNGP मॉडल के प्रदर्शन का मूल्यांकन करें।

CLINC OOS से परे, SNGP मॉडल को बड़े पैमाने के डेटासेट जैसे आरा विषाक्तता का पता लगाने , और छवि डेटासेट जैसे CIFAR-100 और ImageNet पर लागू किया गया है। एसएनजीपी और अन्य अनिश्चितता के तरीकों के बेंचमार्क परिणामों के साथ-साथ एंड-टू-एंड प्रशिक्षण/मूल्यांकन स्क्रिप्ट के साथ उच्च गुणवत्ता वाले कार्यान्वयन के लिए, आप अनिश्चितता बेसलाइन बेंचमार्क देख सकते हैं।

सेट अप

pip uninstall -y tensorflow tf-text

pip install -U tensorflow-text-nightly

pip install -U tf-nightly

pip install -U tf-models-nightly

import matplotlib.pyplot as plt

import sklearn.metrics
import sklearn.calibration

import tensorflow_hub as hub
import tensorflow_datasets as tfds

import numpy as np
import tensorflow as tf

import official.nlp.modeling.layers as layers
import official.nlp.optimization as optimization

/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow_addons/utils/ensure_tf_install.py:43: UserWarning: You are currently using a nightly version of TensorFlow (2.9.0-dev20220203). 
TensorFlow Addons offers no support for the nightly versions of TensorFlow. Some things might work, some other might not. 
If you encounter a bug, do not file an issue on GitHub.
  UserWarning,

इस ट्यूटोरियल को कुशलतापूर्वक चलाने के लिए GPU की आवश्यकता है। जांचें कि क्या GPU उपलब्ध है।

tf.__version__

'2.9.0-dev20220203'

gpus = tf.config.list_physical_devices('GPU')
gpus

[PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]

assert gpus, """
  No GPU(s) found! This tutorial will take many hours to run without a GPU.

  You may hit this error if the installed tensorflow package is not
  compatible with the CUDA and CUDNN versions."""

पहले बीईआरटी ट्यूटोरियल के साथ क्लासिफाई टेक्स्ट के बाद एक मानक बीईआरटी क्लासिफायरियर लागू करें। हम क्लासिफायर के रूप में BERT-बेस एनकोडर और बिल्ट-इन ClassificationHead का उपयोग करेंगे।

मानक बीईआरटी मॉडल

एसएनजीपी मॉडल बनाएं

BERT-SNGP मॉडल को लागू करने के लिए, आपको केवल ClassificationHead को बिल्ट-इन GaussianProcessClassificationHead से बदलना होगा। वर्णक्रमीय सामान्यीकरण पहले से ही इस वर्गीकरण शीर्ष में पूर्व-पैक किया गया है। एसएनजीपी ट्यूटोरियल की तरह, मॉडल में एक कॉन्वर्सिस रीसेट कॉलबैक जोड़ें, इसलिए मॉडल एक ही डेटा को दो बार गिनने से बचने के लिए एक नए युग की शुरुआत में स्वचालित रूप से कॉन्वर्सिस अनुमानक को रीसेट कर देता है।

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

class SNGPBertClassifier(BertClassifier):

  def make_classification_head(self, num_classes, inner_dim, dropout_rate):
    return layers.GaussianProcessClassificationHead(
        num_classes=num_classes, 
        inner_dim=inner_dim,
        dropout_rate=dropout_rate,
        gp_cov_momentum=-1,
        temperature=30.,
        **self.classifier_kwargs)

  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)

CLINC OOS डेटासेट लोड करें

अब CLINC OOS इंटेंट डिटेक्शन डेटासेट लोड करें। इस डेटासेट में 150,000 उपयोगकर्ता की बोली जाने वाली क्वेरीज़ 150 से अधिक इंटेंट क्लासेस में एकत्र की गई हैं, इसमें 1000 आउट-ऑफ-डोमेन (OOD) वाक्य भी शामिल हैं जो किसी भी ज्ञात वर्ग द्वारा कवर नहीं किए गए हैं।

(clinc_train, clinc_test, clinc_test_oos), ds_info = tfds.load(
    'clinc_oos', split=['train', 'test', 'test_oos'], with_info=True, batch_size=-1)

ट्रेन बनाएं और डेटा का परीक्षण करें।

train_examples = clinc_train['text']
train_labels = clinc_train['intent']

# Makes the in-domain (IND) evaluation data.
ind_eval_data = (clinc_test['text'], clinc_test['intent'])

एक OOD मूल्यांकन डेटासेट बनाएँ। इसके लिए, इन-डोमेन परीक्षण डेटा clinc_test और आउट-ऑफ़-डोमेन डेटा clinc_test_oos को संयोजित करें। हम इन-डोमेन उदाहरणों के लिए लेबल 0 और आउट-ऑफ-डोमेन उदाहरणों को लेबल 1 भी निर्दिष्ट करेंगे।

test_data_size = ds_info.splits['test'].num_examples
oos_data_size = ds_info.splits['test_oos'].num_examples

# Combines the in-domain and out-of-domain test examples.
oos_texts = tf.concat([clinc_test['text'], clinc_test_oos['text']], axis=0)
oos_labels = tf.constant([0] * test_data_size + [1] * oos_data_size)

# Converts into a TF dataset.
ood_eval_dataset = tf.data.Dataset.from_tensor_slices(
    {"text": oos_texts, "label": oos_labels})

ट्रेन और मूल्यांकन

पहले बुनियादी प्रशिक्षण विन्यास स्थापित करें।

TRAIN_EPOCHS = 3
TRAIN_BATCH_SIZE = 32
EVAL_BATCH_SIZE = 256


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

fit_configs = dict(batch_size=TRAIN_BATCH_SIZE,
                   epochs=TRAIN_EPOCHS,
                   validation_batch_size=EVAL_BATCH_SIZE, 
                   validation_data=ind_eval_data)

sngp_model = SNGPBertClassifier()
sngp_model.compile(optimizer=optimizer, loss=loss, metrics=metrics)
sngp_model.fit(train_examples, train_labels, **fit_configs)

Epoch 1/3
469/469 [==============================] - 219s 427ms/step - loss: 1.0725 - sparse_categorical_accuracy: 0.7870 - val_loss: 0.4358 - val_sparse_categorical_accuracy: 0.9380
Epoch 2/3
469/469 [==============================] - 198s 422ms/step - loss: 0.0885 - sparse_categorical_accuracy: 0.9797 - val_loss: 0.2424 - val_sparse_categorical_accuracy: 0.9518
Epoch 3/3
469/469 [==============================] - 199s 424ms/step - loss: 0.0259 - sparse_categorical_accuracy: 0.9951 - val_loss: 0.1927 - val_sparse_categorical_accuracy: 0.9642
<keras.callbacks.History at 0x7fe24c0a7090>

OOD प्रदर्शन का मूल्यांकन करें

मूल्यांकन करें कि मॉडल कितनी अच्छी तरह अपरिचित आउट-ऑफ-डोमेन प्रश्नों का पता लगा सकता है। कठोर मूल्यांकन के लिए, पहले निर्मित OOD मूल्यांकन डेटासेट ood_eval_dataset का उपयोग करें।

OOD संभावनाओं की गणना \(1 - p(x)\)रूप में करता है, जहां \(p(x)=softmax(logit(x))\) भविष्य कहनेवाला संभावना है।

sngp_probs, ood_labels = oos_predict(sngp_model, ood_eval_dataset)

ood_probs = 1 - sngp_probs

अब मूल्यांकन करें कि मॉडल का अनिश्चितता स्कोर ood_probs आउट-ऑफ़-डोमेन लेबल की कितनी अच्छी तरह भविष्यवाणी करता है। पहले OOD प्रायिकता बनाम OOD डिटेक्शन सटीकता के लिए सटीक-रिकॉल कर्व (AUPRC) के तहत क्षेत्र की गणना करें।

precision, recall, _ = sklearn.metrics.precision_recall_curve(ood_labels, ood_probs)

auprc = sklearn.metrics.auc(recall, precision)
print(f'SNGP AUPRC: {auprc:.4f}')

SNGP AUPRC: 0.9039

यह अनिश्चितता बेसलाइन के तहत CLINC OOS बेंचमार्क पर रिपोर्ट किए गए SNGP प्रदर्शन से मेल खाता है।

इसके बाद, अनिश्चितता अंशांकन में मॉडल की गुणवत्ता की जांच करें, अर्थात, क्या मॉडल की भविष्य कहनेवाला संभावना इसकी भविष्य कहनेवाला सटीकता से मेल खाती है। एक अच्छी तरह से कैलिब्रेटेड मॉडल को भरोसेमंद माना जाता है, उदाहरण के लिए, इसकी भविष्य कहनेवाला संभावना \(p(x)=0.8\) का मतलब है कि मॉडल 80% समय सही है।

prob_true, prob_pred = sklearn.calibration.calibration_curve(
    ood_labels, ood_probs, n_bins=10, strategy='quantile')
34 एल10एन-प्लेसहोल्डर
plt.plot(prob_pred, prob_true)

plt.plot([0., 1.], [0., 1.], c='k', linestyle="--")
plt.xlabel('Predictive Probability')
plt.ylabel('Predictive Accuracy')
plt.title('Calibration Plots, SNGP')

plt.show()

पीएनजी

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