 TensorFlow.org এ দেখুন |  Google Colab-এ চালান |  GitHub এ দেখুন |  নোটবুক ডাউনলোড করুন |  TF হাব মডেল দেখুন |
SNGP টিউটোরিয়ালে , আপনি শিখেছেন কিভাবে একটি গভীর অবশিষ্ট নেটওয়ার্কের উপরে SNGP মডেল তৈরি করতে হয় যাতে এর অনিশ্চয়তা পরিমাপ করার ক্ষমতা উন্নত করা যায়। এই টিউটোরিয়ালে, আপনি SNGP প্রয়োগ করবেন একটি ন্যাচারাল ল্যাঙ্গুয়েজ বোঝার (NLU) টাস্কে এটিকে একটি গভীর BERT এনকোডারের উপরে তৈরি করে গভীর NLU মডেলের সুযোগ-সুবিধা বহির্ভূত প্রশ্নগুলি সনাক্ত করার ক্ষমতা উন্নত করতে।
বিশেষ করে, আপনি করবেন:
- BERT-SNGP তৈরি করুন, একটি SNGP- বর্ধিত BERT মডেল।
- CLINC আউট-অফ-স্কোপ (OOS) অভিপ্রায় সনাক্তকরণ ডেটাসেট লোড করুন।
- BERT-SNGP মডেলের প্রশিক্ষণ দিন।
- অনিশ্চয়তা ক্রমাঙ্কন এবং ডোমেনের বাইরে সনাক্তকরণে BERT-SNGP মডেলের কর্মক্ষমতা মূল্যায়ন করুন।
CLINC OOS এর বাইরে, SNGP মডেলটি জিগস টক্সিসিটি সনাক্তকরণের মতো বড় আকারের ডেটাসেট এবং CIFAR-100 এবং ImageNet- এর মতো চিত্র ডেটাসেটে প্রয়োগ করা হয়েছে। SNGP এবং অন্যান্য অনিশ্চয়তা পদ্ধতির বেঞ্চমার্ক ফলাফলের জন্য, সেইসাথে শেষ থেকে শেষ প্রশিক্ষণ/মূল্যায়ন স্ক্রিপ্ট সহ উচ্চ-মানের বাস্তবায়নের জন্য, আপনি অনিশ্চয়তার বেসলাইন বেঞ্চমার্কটি দেখতে পারেন।
সেটআপ
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 প্রয়োজন। জিপিইউ উপলব্ধ কিনা তা পরীক্ষা করুন।
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 টিউটোরিয়াল সহ শ্রেণীবদ্ধ টেক্সট অনুসরণ করে একটি আদর্শ BERT শ্রেণীবদ্ধকারী প্রয়োগ করুন। আমরা BERT-বেস এনকোডার এবং বিল্ট-ইন ClassificationHead ক্লাসিফায়ার হিসেবে ব্যবহার করব।
স্ট্যান্ডার্ড BERT মডেল
PREPROCESS_HANDLE = 'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3'
MODEL_HANDLE = 'https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/3'
class BertClassifier(tf.keras.Model):
def __init__(self,
num_classes=150, inner_dim=768, dropout_rate=0.1,
**classifier_kwargs):
super().__init__()
self.classifier_kwargs = classifier_kwargs
# Initiate the BERT encoder components.
self.bert_preprocessor = hub.KerasLayer(PREPROCESS_HANDLE, name='preprocessing')
self.bert_hidden_layer = hub.KerasLayer(MODEL_HANDLE, trainable=True, name='bert_encoder')
# Defines the encoder and classification layers.
self.bert_encoder = self.make_bert_encoder()
self.classifier = self.make_classification_head(num_classes, inner_dim, dropout_rate)
def make_bert_encoder(self):
text_inputs = tf.keras.layers.Input(shape=(), dtype=tf.string, name='text')
encoder_inputs = self.bert_preprocessor(text_inputs)
encoder_outputs = self.bert_hidden_layer(encoder_inputs)
return tf.keras.Model(text_inputs, encoder_outputs)
def make_classification_head(self, num_classes, inner_dim, dropout_rate):
return layers.ClassificationHead(
num_classes=num_classes,
inner_dim=inner_dim,
dropout_rate=dropout_rate,
**self.classifier_kwargs)
def call(self, inputs, **kwargs):
encoder_outputs = self.bert_encoder(inputs)
classifier_inputs = encoder_outputs['sequence_output']
return self.classifier(classifier_inputs, **kwargs)
এসএনজিপি মডেল তৈরি করুন
একটি BERT-SNGP মডেল বাস্তবায়ন করতে, আপনাকে শুধুমাত্র অন্তর্নির্মিত GaussianProcessClassificationHead দিয়ে ClassificationHead প্রতিস্থাপন করতে হবে। বর্ণালী স্বাভাবিকীকরণ ইতিমধ্যে এই শ্রেণীবিভাগের শিরোনামে প্রাক-প্যাকেজ করা হয়েছে। SNGP টিউটোরিয়ালের মতো, মডেলটিতে একটি কোভেরিয়েন্স রিসেট কলব্যাক যোগ করুন, তাই একই ডেটা দুবার গণনা এড়াতে মডেলটি একটি নতুন যুগের শুরুতে স্বয়ংক্রিয়ভাবে কোভেরিয়েন্স অনুমানকারী রিসেট করে।
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 অভিপ্রায় সনাক্তকরণ ডেটাসেট লোড করুন। এই ডেটাসেটে রয়েছে 15000টি ব্যবহারকারীর কথ্য প্রশ্ন সংগৃহীত 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
def bert_optimizer(learning_rate,
batch_size=TRAIN_BATCH_SIZE, epochs=TRAIN_EPOCHS,
warmup_rate=0.1):
"""Creates an AdamWeightDecay optimizer with learning rate schedule."""
train_data_size = ds_info.splits['train'].num_examples
steps_per_epoch = int(train_data_size / batch_size)
num_train_steps = steps_per_epoch * epochs
num_warmup_steps = int(warmup_rate * num_train_steps)
# Creates learning schedule.
lr_schedule = tf.keras.optimizers.schedules.PolynomialDecay(
initial_learning_rate=learning_rate,
decay_steps=num_train_steps,
end_learning_rate=0.0)
return optimization.AdamWeightDecay(
learning_rate=lr_schedule,
weight_decay_rate=0.01,
epsilon=1e-6,
exclude_from_weight_decay=['LayerNorm', 'layer_norm', 'bias'])
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 ব্যবহার করুন।
def oos_predict(model, ood_eval_dataset, **model_kwargs):
oos_labels = []
oos_probs = []
ood_eval_dataset = ood_eval_dataset.batch(EVAL_BATCH_SIZE)
for oos_batch in ood_eval_dataset:
oos_text_batch = oos_batch["text"]
oos_label_batch = oos_batch["label"]
pred_logits = model(oos_text_batch, **model_kwargs)
pred_probs_all = tf.nn.softmax(pred_logits, axis=-1)
pred_probs = tf.reduce_max(pred_probs_all, axis=-1)
oos_labels.append(oos_label_batch)
oos_probs.append(pred_probs)
oos_probs = tf.concat(oos_probs, axis=0)
oos_labels = tf.concat(oos_labels, axis=0)
return oos_probs, oos_labels
\(1 - p(x)\)হিসাবে OOD সম্ভাব্যতা গণনা করে, যেখানে \(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')
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()
সম্পদ এবং আরও পড়া
- স্ক্র্যাচ থেকে SNGP বাস্তবায়নের বিস্তারিত ওয়াকথ্রু জন্য SNGP টিউটোরিয়াল দেখুন।
- বিভিন্ন ধরণের বেঞ্চমার্ক ডেটাসেটে (যেমন, CIFAR , ImageNet , Jigsaw টক্সিসিটি সনাক্তকরণ ইত্যাদি) SNGP মডেল (এবং অন্যান্য অনেক অনিশ্চয়তা পদ্ধতি) বাস্তবায়নের জন্য অনিশ্চয়তা বেসলাইন দেখুন।
- SNGP পদ্ধতির আরও গভীরভাবে বোঝার জন্য, দূরত্ব সচেতনতার মাধ্যমে ডিটারমিনিস্টিক ডিপ লার্নিং সহ সরল এবং নীতিগত অনিশ্চয়তা অনুমানের কাগজটি দেখুন।