अपने स्थानीय TensorFlow के लिए RSVP आज हर जगह घटना!
इस पेज का अनुवाद Cloud Translation API से किया गया है.
Switch to English

BERT के साथ टेक्स्ट को वर्गीकृत करें

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

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

इस नोटबुक में, आप करेंगे:

  • IMDB डेटासेट लोड करें
  • TensorFlow हब से एक BERT मॉडल लोड करें
  • BERT को क्लासिफायर के साथ जोड़कर अपना मॉडल बनाएं
  • उसी के भाग के रूप में अपने स्वयं के मॉडल, ठीक ट्यूनिंग BERT को प्रशिक्षित करें
  • अपने मॉडल को सहेजें और वाक्यों को वर्गीकृत करने के लिए इसका उपयोग करें

यदि आप IMDB डेटासेट के साथ काम करने के लिए नए हैं, तो अधिक जानकारी के लिए बेसिक टेक्स्ट वर्गीकरण देखें।

BERT के बारे में

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

BERT मॉडल आमतौर पर पाठ के एक बड़े कोष पर पहले से प्रशिक्षित होते हैं, फिर विशिष्ट कार्यों के लिए ठीक-ठीक ट्यून किए जाते हैं।

सेट अप

# A dependency of the preprocessing for BERT inputs
pip install -q tensorflow-text

आप एडमोर अनुकूलक का उपयोग टेंसोफ़्लो / मॉडल से करेंगे

pip install -q tf-models-official
import os
import shutil

import tensorflow as tf
import tensorflow_hub as hub
import tensorflow_text as text
from official.nlp import optimization  # to create AdamW optmizer

import matplotlib.pyplot as plt

tf.get_logger().setLevel('ERROR')

भावनाओं का विश्लेषण

यह नोटबुक समीक्षा के पाठ के आधार पर फिल्म समीक्षाओं को सकारात्मक या नकारात्मक के रूप में वर्गीकृत करने के लिए एक भावना विश्लेषण मॉडल को प्रशिक्षित करती है।

आप लार्ज मूवी रिव्यू डेटासेट का उपयोग करेंगे जिसमें इंटरनेट मूवी डेटाबेस से 50,000 मूवी रिव्यू का पाठ शामिल है।

IMDB डेटासेट डाउनलोड करें

चलो डेटासेट डाउनलोड करें और निकालें, फिर निर्देशिका संरचना का अन्वेषण करें।

url = 'https://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz'

dataset = tf.keras.utils.get_file('aclImdb_v1.tar.gz', url,
                                  untar=True, cache_dir='.',
                                  cache_subdir='')

dataset_dir = os.path.join(os.path.dirname(dataset), 'aclImdb')

train_dir = os.path.join(dataset_dir, 'train')

# remove unused folders to make it easier to load the data
remove_dir = os.path.join(train_dir, 'unsup')
shutil.rmtree(remove_dir)
Downloading data from https://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz
84131840/84125825 [==============================] - 7s 0us/step

अगला, आप एक लेबलtf.data.Dataset बनाने के लिए text_dataset_from_directory उपयोगिता का उपयोग करेंगे।

IMDB डेटासेट पहले ही ट्रेन और टेस्ट में विभाजित हो चुका है, लेकिन इसमें सत्यापन सेट का अभाव है। आइए नीचे दिए गए validation_split तर्क का उपयोग करके प्रशिक्षण डेटा के 80:20 विभाजन का उपयोग करके एक सत्यापन सेट बनाएं।

AUTOTUNE = tf.data.AUTOTUNE
batch_size = 32
seed = 42

raw_train_ds = tf.keras.preprocessing.text_dataset_from_directory(
    'aclImdb/train',
    batch_size=batch_size,
    validation_split=0.2,
    subset='training',
    seed=seed)

class_names = raw_train_ds.class_names
train_ds = raw_train_ds.cache().prefetch(buffer_size=AUTOTUNE)

val_ds = tf.keras.preprocessing.text_dataset_from_directory(
    'aclImdb/train',
    batch_size=batch_size,
    validation_split=0.2,
    subset='validation',
    seed=seed)

val_ds = val_ds.cache().prefetch(buffer_size=AUTOTUNE)

test_ds = tf.keras.preprocessing.text_dataset_from_directory(
    'aclImdb/test',
    batch_size=batch_size)

test_ds = test_ds.cache().prefetch(buffer_size=AUTOTUNE)
Found 25000 files belonging to 2 classes.
Using 20000 files for training.
Found 25000 files belonging to 2 classes.
Using 5000 files for validation.
Found 25000 files belonging to 2 classes.

आइए कुछ समीक्षाओं पर एक नज़र डालें।

for text_batch, label_batch in train_ds.take(1):
  for i in range(3):
    print(f'Review: {text_batch.numpy()[i]}')
    label = label_batch.numpy()[i]
    print(f'Label : {label} ({class_names[label]})')
Review: b'"Pandemonium" is a horror movie spoof that comes off more stupid than funny. Believe me when I tell you, I love comedies. Especially comedy spoofs. "Airplane", "The Naked Gun" trilogy, "Blazing Saddles", "High Anxiety", and "Spaceballs" are some of my favorite comedies that spoof a particular genre. "Pandemonium" is not up there with those films. Most of the scenes in this movie had me sitting there in stunned silence because the movie wasn\'t all that funny. There are a few laughs in the film, but when you watch a comedy, you expect to laugh a lot more than a few times and that\'s all this film has going for it. Geez, "Scream" had more laughs than this film and that was more of a horror film. How bizarre is that?<br /><br />*1/2 (out of four)'
Label : 0 (neg)
Review: b"David Mamet is a very interesting and a very un-equal director. His first movie 'House of Games' was the one I liked best, and it set a series of films with characters whose perspective of life changes as they get into complicated situations, and so does the perspective of the viewer.<br /><br />So is 'Homicide' which from the title tries to set the mind of the viewer to the usual crime drama. The principal characters are two cops, one Jewish and one Irish who deal with a racially charged area. The murder of an old Jewish shop owner who proves to be an ancient veteran of the Israeli Independence war triggers the Jewish identity in the mind and heart of the Jewish detective.<br /><br />This is were the flaws of the film are the more obvious. The process of awakening is theatrical and hard to believe, the group of Jewish militants is operatic, and the way the detective eventually walks to the final violent confrontation is pathetic. The end of the film itself is Mamet-like smart, but disappoints from a human emotional perspective.<br /><br />Joe Mantegna and William Macy give strong performances, but the flaws of the story are too evident to be easily compensated."
Label : 0 (neg)
Review: b'Great documentary about the lives of NY firefighters during the worst terrorist attack of all time.. That reason alone is why this should be a must see collectors item.. What shocked me was not only the attacks, but the"High Fat Diet" and physical appearance of some of these firefighters. I think a lot of Doctors would agree with me that,in the physical shape they were in, some of these firefighters would NOT of made it to the 79th floor carrying over 60 lbs of gear. Having said that i now have a greater respect for firefighters and i realize becoming a firefighter is a life altering job. The French have a history of making great documentary\'s and that is what this is, a Great Documentary.....'
Label : 1 (pos)

TensorFlow हब से लोड हो रहे मॉडल

यहां आप चुन सकते हैं कि कौन सा BERT मॉडल आप TensorFlow Hub और फाइन-ट्यून से लोड करेंगे। कई BERT मॉडल उपलब्ध हैं।

  • BERT-Base , बिना लाइसेंस वाले और मूल BERT लेखकों द्वारा जारी प्रशिक्षण भार के साथ सात और मॉडल
  • छोटे BERTs में समान सामान्य वास्तुकला लेकिन कम और / या छोटे ट्रांसफार्मर ब्लॉक होते हैं, जो आपको गति, आकार और गुणवत्ता के बीच ट्रेडऑफ़ का पता लगाने देता है।
  • ALBERT : "A Lite BERT" के चार अलग-अलग आकार जो परतों के बीच मापदंडों को साझा करके मॉडल आकार (लेकिन गणना समय नहीं) को कम करते हैं।
  • बीईआरटी विशेषज्ञ : आठ मॉडल जो सभी में बीईआरटी-बेस वास्तुकला है, लेकिन विभिन्न पूर्व-प्रशिक्षण डोमेन के बीच एक विकल्प प्रदान करते हैं, लक्ष्य कार्य के साथ अधिक निकटता संरेखित करने के लिए।
  • इलेक्ट्रा में BERT (तीन अलग-अलग आकारों में) के समान वास्तुकला है, लेकिन एक सेट-अप में एक भेदभावपूर्ण के रूप में पूर्व-प्रशिक्षित हो जाता है जो एक जनरेटिव एडवरसरी नेटवर्क (GAN) जैसा दिखता है।
  • टॉकिंग-हेड्स अटेंशन और गेटेड GELU [ बेस , बड़े ] के साथ BERT में ट्रांसफॉर्मर आर्किटेक्चर के मूल में दो सुधार हैं।

TensorFlow हब पर मॉडल प्रलेखन में अधिक विवरण और शोध साहित्य के संदर्भ हैं। उपरोक्त लिंक का पालन करें, या अगले सेल निष्पादन के बाद मुद्रित tfhub.dev URL पर क्लिक करें।

सुझाव है कि छोटे बीईआरटी (कम मापदंडों के साथ) के साथ शुरू किया जाए क्योंकि वे ठीक-ठाक करने के लिए तेज़ हैं। यदि आपको एक छोटा मॉडल पसंद है लेकिन उच्च सटीकता के साथ, ALBERT आपका अगला विकल्प हो सकता है। यदि आप और भी बेहतर सटीकता चाहते हैं, तो क्लासिक BERT आकारों में से एक या उनके हाल के परिशोधन जैसे Electra, Talking Heads, या BERT Expert चुनें।

नीचे उपलब्ध मॉडलों के अलावा, ऐसे मॉडल के कई संस्करण हैं जो बड़े हैं और बेहतर सटीकता से भी जुड़ सकते हैं लेकिन वे एक ही जीपीयू पर ठीक होने के लिए बहुत बड़े हैं। आप ऐसा कर पाएंगे कि TPU कोलैब पर BERT का उपयोग करके हल हल कार्यों पर

आप नीचे दिए गए कोड में देखेंगे कि tfhub.dev URL स्विच करना इनमें से किसी भी मॉडल को आज़माने के लिए पर्याप्त है, क्योंकि इन दोनों के बीच के अंतर को TF हब से SavedModels में एन्क्रिप्ट किया गया है।

ठीक करने के लिए एक BERT मॉडल चुनें

BERT model selected           : https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-512_A-8/1
Preprocess model auto-selected: https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3

है

प्रीप्रोसेसिंग मॉडल

टेक्स्ट इनपुट को BERT में इनपुट करने से पहले न्यूमेरिक टोकन आईडी में बदल दिया जाता है और कई टेन्सर्स में व्यवस्थित किया जाता है। TensorFlow हब ऊपर चर्चा किए गए प्रत्येक BERT मॉडल के लिए एक मिलान प्रीप्रोसेसिंग मॉडल प्रदान करता है, जो TF.text लाइब्रेरी से TF ऑप्स का उपयोग करके इस परिवर्तन को लागू करता है। अपने TensorFlow मॉडल के बाहर शुद्ध पायथन कोड को चलाना आवश्यक नहीं है पाठ को प्रीप्रोसेस करें।

प्रीप्रोसेसिंग मॉडल को बीईआरटी मॉडल के प्रलेखन द्वारा संदर्भित होना चाहिए, जिसे आप ऊपर मुद्रित URL पर पढ़ सकते हैं। उपरोक्त ड्रॉप-डाउन से BERT मॉडल के लिए, प्रीप्रोसेसिंग मॉडल स्वचालित रूप से चुना जाता है।

bert_preprocess_model = hub.KerasLayer(tfhub_handle_preprocess)

आइए कुछ टेक्स्ट पर प्रीप्रोसेसिंग मॉडल आज़माएँ और आउटपुट देखें:

text_test = ['this is such an amazing movie!']
text_preprocessed = bert_preprocess_model(text_test)

print(f'Keys       : {list(text_preprocessed.keys())}')
print(f'Shape      : {text_preprocessed["input_word_ids"].shape}')
print(f'Word Ids   : {text_preprocessed["input_word_ids"][0, :12]}')
print(f'Input Mask : {text_preprocessed["input_mask"][0, :12]}')
print(f'Type Ids   : {text_preprocessed["input_type_ids"][0, :12]}')
Keys       : ['input_mask', 'input_word_ids', 'input_type_ids']
Shape      : (1, 128)
Word Ids   : [ 101 2023 2003 2107 2019 6429 3185  999  102    0    0    0]
Input Mask : [1 1 1 1 1 1 1 1 1 0 0 0]
Type Ids   : [0 0 0 0 0 0 0 0 0 0 0 0]

जैसा कि आप देख सकते हैं, अब आपके पास input_words_id से 3 आउटपुट हैं जो एक BERT मॉडल का उपयोग करेगा ( input_words_id , input_mask और input_type_ids )।

कुछ अन्य महत्वपूर्ण बिंदु:

  • इनपुट को 128 टोकनों में काट दिया जाता है। टोकन की संख्या को अनुकूलित किया जा सकता है और आप टीपीयू कोलाब पर बीईआरटी का उपयोग करके हल करें कार्यों पर अधिक विवरण देख सकते हैं।
  • input_type_ids केवल एक मान (0) है क्योंकि यह एक एकल वाक्य इनपुट है। एक से अधिक वाक्य इनपुट के लिए, इसमें प्रत्येक इनपुट के लिए एक नंबर होगा।

चूंकि यह टेक्स्ट प्रीप्रोसेसर एक TensorFlow मॉडल है, इसलिए इसे सीधे आपके मॉडल में शामिल किया जा सकता है।

BERT मॉडल का उपयोग करना

अपने मॉडल में BERT डालने से पहले, आइए इसके आउटपुट पर एक नज़र डालते हैं। आप इसे TF हब से लोड करेंगे और लौटे मानों को देखेंगे।

bert_model = hub.KerasLayer(tfhub_handle_encoder)
bert_results = bert_model(text_preprocessed)

print(f'Loaded BERT: {tfhub_handle_encoder}')
print(f'Pooled Outputs Shape:{bert_results["pooled_output"].shape}')
print(f'Pooled Outputs Values:{bert_results["pooled_output"][0, :12]}')
print(f'Sequence Outputs Shape:{bert_results["sequence_output"].shape}')
print(f'Sequence Outputs Values:{bert_results["sequence_output"][0, :12]}')
Loaded BERT: https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-512_A-8/1
Pooled Outputs Shape:(1, 512)
Pooled Outputs Values:[ 0.76262873  0.9928097  -0.18611881  0.36673862  0.15233737  0.6550447
  0.9681153  -0.9486272   0.00216161 -0.9877732   0.06842697 -0.9763058 ]
Sequence Outputs Shape:(1, 128, 512)
Sequence Outputs Values:[[-0.28946346  0.34321272  0.33231515 ...  0.21300808  0.71020764
  -0.05771098]
 [-0.28742087  0.31980985 -0.23018607 ...  0.58455014 -0.21329728
   0.72692114]
 [-0.6615697   0.6887685  -0.87432986 ...  0.10877222 -0.2617324
   0.4785539 ]
 ...
 [-0.22561133 -0.2892562  -0.07064445 ...  0.47565985  0.83277136
   0.40025374]
 [-0.29824236 -0.27473187 -0.05450562 ...  0.48849723  1.0955356
   0.1816333 ]
 [-0.4437813   0.00930756  0.07223685 ...  0.17290069  1.1833248
   0.07897997]]

बर्ट मॉडल 3 महत्वपूर्ण कुंजी के साथ एक नक्शे को वापस: pooled_output , sequence_output , encoder_outputs :

  • एक पूरे के रूप में प्रत्येक इनपुट अनुक्रम का प्रतिनिधित्व करने के लिए pooled_output । आकार [batch_size, H] । आप इसे पूरी फिल्म समीक्षा के लिए एक एम्बेडिंग के रूप में सोच सकते हैं।
  • sequence_output संदर्भ में प्रत्येक इनपुट टोकन का प्रतिनिधित्व करता है। आकार [batch_size, seq_length, H] । आप इसे फिल्म की समीक्षा में हर टोकन के लिए एक संदर्भ के रूप में सोच सकते हैं।
  • encoder_outputs L ट्रांसफार्मर ब्लॉक की मध्यवर्ती encoder_outputs हैं। outputs["encoder_outputs"][i] आकार का एक टेंसर है [batch_size, seq_length, 1024] i-th ट्रांसफार्मर ब्लॉक के आउटपुट के साथ, 0 <= i < L । सूची के अंतिम मूल्य के बराबर है sequence_output

ठीक ट्यूनिंग के लिए आप pooled_output सरणी का उपयोग करने जा रहे हैं।

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

प्रीप्रोसेसिंग मॉडल, चयनित बीईआरटी मॉडल, एक डेंस और एक ड्रॉपआउट परत के साथ, आप एक बहुत ही सरल फाइन-ट्यून मॉडल बनाएंगे।

def build_classifier_model():
  text_input = tf.keras.layers.Input(shape=(), dtype=tf.string, name='text')
  preprocessing_layer = hub.KerasLayer(tfhub_handle_preprocess, name='preprocessing')
  encoder_inputs = preprocessing_layer(text_input)
  encoder = hub.KerasLayer(tfhub_handle_encoder, trainable=True, name='BERT_encoder')
  outputs = encoder(encoder_inputs)
  net = outputs['pooled_output']
  net = tf.keras.layers.Dropout(0.1)(net)
  net = tf.keras.layers.Dense(1, activation=None, name='classifier')(net)
  return tf.keras.Model(text_input, net)

आइए देखें कि मॉडल प्रीप्रोसेसिंग मॉडल के आउटपुट से चलता है।

classifier_model = build_classifier_model()
bert_raw_result = classifier_model(tf.constant(text_test))
print(tf.sigmoid(bert_raw_result))
tf.Tensor([[0.3188841]], shape=(1, 1), dtype=float32)

आउटपुट अर्थहीन है, ज़ाहिर है, क्योंकि मॉडल अभी तक प्रशिक्षित नहीं हुआ है।

आइए मॉडल की संरचना पर एक नज़र डालें।

tf.keras.utils.plot_model(classifier_model)

पींग

मॉडल प्रशिक्षण

अब आपके पास एक मॉडल को प्रशिक्षित करने के लिए सभी टुकड़े हैं, जिसमें प्रीप्रोसेसिंग मॉड्यूल, बीईआरटी एनकोडर, डेटा और क्लासिफायरियर शामिल हैं।

लॉस फंकशन

चूंकि यह एक द्विआधारी वर्गीकरण समस्या है और मॉडल एक संभावना (एकल-इकाई परत) को आउटपुट करता है, आप नुकसान का उपयोग करेंगे। losses.BinaryCrossentropy loss function।

loss = tf.keras.losses.BinaryCrossentropy(from_logits=True)
metrics = tf.metrics.BinaryAccuracy()

ऑप्टिमाइज़र

ठीक-ट्यूनिंग के लिए, चलो उसी ऑप्टिमाइज़र का उपयोग करें जिसे BERT मूल रूप से "एडेप्टिव मोमेंट्स" (एडम) के साथ प्रशिक्षित किया गया था। यह ऑप्टिमाइज़र भविष्यवाणी हानि को कम करता है और वजन कम करने (क्षणों का उपयोग नहीं करने) द्वारा नियमित करता है, जिसे एडम डब्ल्यूडब्ल्यूडब्ल्यू के रूप में भी जाना जाता है।

सीखने की दर ( init_lr ) के लिए, हम BERT पूर्व-प्रशिक्षण के समान शेड्यूल का उपयोग करते हैं: एक प्रारंभिक प्रारंभिक शिक्षण दर के रैखिक क्षय, पहले चरण के 10% प्रशिक्षण चरणों ( num_warmup_steps ) पर एक रैखिक वार्म-अप चरण के साथ उपसर्ग किया जाता है। बीईआरटी पेपर के अनुरूप, प्रारंभिक शिक्षण दर फाइन-ट्यूनिंग के लिए छोटा है (5e-5, 3e-5, 2e-5 का सर्वोत्तम)।

epochs = 5
steps_per_epoch = tf.data.experimental.cardinality(train_ds).numpy()
num_train_steps = steps_per_epoch * epochs
num_warmup_steps = int(0.1*num_train_steps)

init_lr = 3e-5
optimizer = optimization.create_optimizer(init_lr=init_lr,
                                          num_train_steps=num_train_steps,
                                          num_warmup_steps=num_warmup_steps,
                                          optimizer_type='adamw')

BERT मॉडल और प्रशिक्षण लोड हो रहा है

आपने पहले बनाए गए classifier_model का उपयोग करके, आप मॉडल को नुकसान, मीट्रिक और ऑप्टिमाइज़र के साथ संकलित कर सकते हैं।

classifier_model.compile(optimizer=optimizer,
                         loss=loss,
                         metrics=metrics)
print(f'Training model with {tfhub_handle_encoder}')
history = classifier_model.fit(x=train_ds,
                               validation_data=val_ds,
                               epochs=epochs)
Training model with https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-512_A-8/1
Epoch 1/5
625/625 [==============================] - 92s 137ms/step - loss: 0.5688 - binary_accuracy: 0.6675 - val_loss: 0.3916 - val_binary_accuracy: 0.8320
Epoch 2/5
625/625 [==============================] - 84s 135ms/step - loss: 0.3597 - binary_accuracy: 0.8347 - val_loss: 0.3796 - val_binary_accuracy: 0.8418
Epoch 3/5
625/625 [==============================] - 85s 137ms/step - loss: 0.2708 - binary_accuracy: 0.8851 - val_loss: 0.4096 - val_binary_accuracy: 0.8408
Epoch 4/5
625/625 [==============================] - 84s 135ms/step - loss: 0.2107 - binary_accuracy: 0.9128 - val_loss: 0.4370 - val_binary_accuracy: 0.8474
Epoch 5/5
625/625 [==============================] - 83s 133ms/step - loss: 0.1565 - binary_accuracy: 0.9363 - val_loss: 0.4855 - val_binary_accuracy: 0.8482

मॉडल का मूल्यांकन करें

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

loss, accuracy = classifier_model.evaluate(test_ds)

print(f'Loss: {loss}')
print(f'Accuracy: {accuracy}')
782/782 [==============================] - 62s 79ms/step - loss: 0.4554 - binary_accuracy: 0.8575
Loss: 0.4553569555282593
Accuracy: 0.8575199842453003

सटीकता और समय के साथ नुकसान की साजिश

model.fit() द्वारा लौटाए गए History ऑब्जेक्ट के आधार पर। आप तुलना और साथ ही प्रशिक्षण और सत्यापन सटीकता के लिए प्रशिक्षण और सत्यापन हानि की साजिश कर सकते हैं:

history_dict = history.history
print(history_dict.keys())

acc = history_dict['binary_accuracy']
val_acc = history_dict['val_binary_accuracy']
loss = history_dict['loss']
val_loss = history_dict['val_loss']

epochs = range(1, len(acc) + 1)
fig = plt.figure(figsize=(10, 6))
fig.tight_layout()

plt.subplot(2, 1, 1)
# "bo" is for "blue dot"
plt.plot(epochs, loss, 'r', label='Training loss')
# b is for "solid blue line"
plt.plot(epochs, val_loss, 'b', label='Validation loss')
plt.title('Training and validation loss')
# plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()

plt.subplot(2, 1, 2)
plt.plot(epochs, acc, 'r', label='Training acc')
plt.plot(epochs, val_acc, 'b', label='Validation acc')
plt.title('Training and validation accuracy')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend(loc='lower right')
dict_keys(['loss', 'binary_accuracy', 'val_loss', 'val_binary_accuracy'])

<matplotlib.legend.Legend at 0x7fa8f81becc0>

पींग

इस साजिश में, लाल रेखाएं प्रशिक्षण हानि और सटीकता का प्रतिनिधित्व करती हैं, और नीली रेखाएं सत्यापन हानि और सटीकता हैं।

अनुमान के लिए निर्यात करें

अब आप बाद में उपयोग के लिए अपने ठीक-ठीक मॉडल को बचा लें।

dataset_name = 'imdb'
saved_model_path = './{}_bert'.format(dataset_name.replace('/', '_'))

classifier_model.save(saved_model_path, include_optimizer=False)
WARNING:absl:Found untraced functions such as restored_function_body, restored_function_body, restored_function_body, restored_function_body, restored_function_body while saving (showing 5 of 310). These functions will not be directly callable after loading.
WARNING:absl:Found untraced functions such as restored_function_body, restored_function_body, restored_function_body, restored_function_body, restored_function_body while saving (showing 5 of 310). These functions will not be directly callable after loading.

चलो मॉडल को फिर से लोड करें ताकि आप उस मॉडल के साथ कंधे से कंधा मिलाकर कोशिश कर सकें जो अभी भी स्मृति में है।

reloaded_model = tf.saved_model.load(saved_model_path)

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

def print_my_examples(inputs, results):
  result_for_printing = \
    [f'input: {inputs[i]:<30} : score: {results[i][0]:.6f}'
                         for i in range(len(inputs))]
  print(*result_for_printing, sep='\n')
  print()


examples = [
    'this is such an amazing movie!',  # this is the same sentence tried earlier
    'The movie was great!',
    'The movie was meh.',
    'The movie was okish.',
    'The movie was terrible...'
]

reloaded_results = tf.sigmoid(reloaded_model(tf.constant(examples)))
original_results = tf.sigmoid(classifier_model(tf.constant(examples)))

print('Results from the saved model:')
print_my_examples(examples, reloaded_results)
print('Results from the model in memory:')
print_my_examples(examples, original_results)
Results from the saved model:
input: this is such an amazing movie! : score: 0.999329
input: The movie was great!           : score: 0.994107
input: The movie was meh.             : score: 0.865047
input: The movie was okish.           : score: 0.030797
input: The movie was terrible...      : score: 0.000901

Results from the model in memory:
input: this is such an amazing movie! : score: 0.999329
input: The movie was great!           : score: 0.994107
input: The movie was meh.             : score: 0.865047
input: The movie was okish.           : score: 0.030797
input: The movie was terrible...      : score: 0.000901


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

serving_results = reloaded_model \
            .signatures['serving_default'](tf.constant(examples))

serving_results = tf.sigmoid(serving_results['classifier'])

print_my_examples(examples, serving_results)
input: this is such an amazing movie! : score: 0.999329
input: The movie was great!           : score: 0.994107
input: The movie was meh.             : score: 0.865048
input: The movie was okish.           : score: 0.030797
input: The movie was terrible...      : score: 0.000901


अगला कदम

अगले चरण के रूप में, आप TPU पर चलने वाले TPU ट्यूटोरियल पर BERT का उपयोग करके GLUE कार्यों को हल करने का प्रयास कर सकते हैं और आपको दिखा सकते हैं कि एकाधिक इनपुट के साथ कैसे काम किया जाए।