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

भावना वर्गीकरण के लिए ग्राफ नियमितीकरण संश्लेषित रेखांकन का उपयोग कर

TensorFlow.org पर देखें गूगल Colab में चलाएँ GitHub पर स्रोत देखें

अवलोकन

सकारात्मक या नकारात्मक रूप में इस नोटबुक का वर्गीकरण फिल्म समीक्षा समीक्षा के पाठ का उपयोग कर। यह द्विआधारी वर्गीकरण, मशीन सीखने समस्या का एक महत्वपूर्ण और व्यापक रूप से लागू तरह का एक उदाहरण है।

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

  1. इनपुट में प्रत्येक पाठ नमूने के लिए embeddings बनाएँ। इस तरह के रूप में पूर्व प्रशिक्षित मॉडल का उपयोग किया जा सकता है word2vec , फिरकी , बर्ट आदि
  2. एक समानता का उपयोग करके इन embeddings के आधार पर एक ग्राफ का निर्माण मीट्रिक जैसे 'एल 2' दूरी 'कोज्या' ग्राफ अनुरूप में नमूने और किनारों को ग्राफ के अनुरूप में समानता के लिए नमूने के जोड़े के बीच की दूरी, आदि के रूप में नोड्स।
  3. ऊपर संश्लेषित ग्राफ और नमूना सुविधाओं से प्रशिक्षण डेटा उत्पन्न करें। जिसके परिणामस्वरूप प्रशिक्षण डेटा मूल नोड सुविधाओं के अलावा पड़ोसी सुविधाओं शामिल होंगे।
  4. Keras अनुक्रमिक, कार्यात्मक, या उपवर्ग एपीआई का उपयोग कर एक बेस मॉडल के रूप में एक तंत्रिका नेटवर्क बनाएँ।
  5. GraphRegularization आवरण वर्ग है, जो NSL ढांचे द्वारा प्रदान की जाती है के साथ बेस मॉडल लपेटें, एक नया ग्राफ Keras मॉडल बनाने के लिए। इस नए मॉडल अपने प्रशिक्षण उद्देश्य में नियमितीकरण शब्द के रूप में एक ग्राफ नियमितीकरण नुकसान शामिल होंगे।
  6. ट्रेन और ग्राफ Keras मॉडल का मूल्यांकन।

आवश्यकताएँ

  1. तंत्रिका संरचित सीखने पैकेज इंस्टॉल करें।
  2. tensorflow हब स्थापित करें।
pip install --quiet neural-structured-learning
pip install --quiet tensorflow-hub

निर्भरता हैं और आयात

 import matplotlib.pyplot as plt
import numpy as np

import neural_structured_learning as nsl

import tensorflow as tf
import tensorflow_hub as hub

# Resets notebook state
tf.keras.backend.clear_session()

print("Version: ", tf.__version__)
print("Eager mode: ", tf.executing_eagerly())
print("Hub version: ", hub.__version__)
print(
    "GPU is",
    "available" if tf.config.list_physical_devices("GPU") else "NOT AVAILABLE")
 
Version:  2.3.0
Eager mode:  True
Hub version:  0.8.0
GPU is NOT AVAILABLE

IMDB डाटासेट

IMDB डाटासेट से 50,000 फिल्म समीक्षा की पाठ होता है इंटरनेट मूवी डाटाबेस । ये प्रशिक्षण के लिए 25,000 समीक्षा और परीक्षण के लिए 25,000 समीक्षा में विभाजित हैं। प्रशिक्षण और परीक्षण सेट संतुलित जाता है, वे सकारात्मक और नकारात्मक समीक्षा की संख्या बराबर होते हैं।

इस ट्यूटोरियल में, हम IMDB डेटासेट के preprocessed संस्करण का उपयोग करेंगे।

डाउनलोड preprocessed IMDB डाटासेट

IMDB डाटासेट TensorFlow के साथ पैक आता है। यह पहले से ही इस तरह के preprocessed किया गया है कि समीक्षा (शब्दों के चिह्नित क्रम) पूर्णांकों, जहां प्रत्येक पूर्णांक एक शब्दकोश में किसी विशिष्ट शब्द का प्रतिनिधित्व करता है के दृश्यों को बदल दिया गया है।

निम्नलिखित कोड डाउनलोड IMDB डाटासेट (या एक कैश की गई प्रतिलिपि का उपयोग करता है, तो यह पहले से ही डाउनलोड किया गया है):

 imdb = tf.keras.datasets.imdb
(pp_train_data, pp_train_labels), (pp_test_data, pp_test_labels) = (
    imdb.load_data(num_words=10000))
 
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/imdb.npz
17465344/17464789 [==============================] - 0s 0us/step

तर्क num_words=10000 प्रशिक्षण डेटा में शीर्ष 10,000 सबसे अक्सर होने वाली शब्द रहता है। दुर्लभ शब्द शब्दावली प्रबंधनीय के आकार रखने के लिए छोड़ दिए जाते हैं।

डेटा का अन्वेषण करें

के डेटा के प्रारूप को समझने के लिए एक क्षण ले लो। डाटासेट preprocessed आता है: प्रत्येक उदाहरण फिल्म समीक्षा के शब्दों का प्रतिनिधित्व पूर्णांकों की एक सरणी है। प्रत्येक लेबल, या तो 0 या 1 के एक पूर्णांक मूल्य है, जहां 0 एक नकारात्मक समीक्षा है, और 1 की सकारात्मक समीक्षा की है।

 print('Training entries: {}, labels: {}'.format(
    len(pp_train_data), len(pp_train_labels)))
training_samples_count = len(pp_train_data)
 
Training entries: 25000, labels: 25000

समीक्षा की पाठ पूर्णांकों, जहां प्रत्येक पूर्णांक एक शब्दकोश में किसी विशिष्ट शब्द का प्रतिनिधित्व करता है के लिए बदल दिया गया है। यहाँ पहली समीक्षा की तरह दिखता है:

 print(pp_train_data[0])
 
[1, 14, 22, 16, 43, 530, 973, 1622, 1385, 65, 458, 4468, 66, 3941, 4, 173, 36, 256, 5, 25, 100, 43, 838, 112, 50, 670, 2, 9, 35, 480, 284, 5, 150, 4, 172, 112, 167, 2, 336, 385, 39, 4, 172, 4536, 1111, 17, 546, 38, 13, 447, 4, 192, 50, 16, 6, 147, 2025, 19, 14, 22, 4, 1920, 4613, 469, 4, 22, 71, 87, 12, 16, 43, 530, 38, 76, 15, 13, 1247, 4, 22, 17, 515, 17, 12, 16, 626, 18, 2, 5, 62, 386, 12, 8, 316, 8, 106, 5, 4, 2223, 5244, 16, 480, 66, 3785, 33, 4, 130, 12, 16, 38, 619, 5, 25, 124, 51, 36, 135, 48, 25, 1415, 33, 6, 22, 12, 215, 28, 77, 52, 5, 14, 407, 16, 82, 2, 8, 4, 107, 117, 5952, 15, 256, 4, 2, 7, 3766, 5, 723, 36, 71, 43, 530, 476, 26, 400, 317, 46, 7, 4, 2, 1029, 13, 104, 88, 4, 381, 15, 297, 98, 32, 2071, 56, 26, 141, 6, 194, 7486, 18, 4, 226, 22, 21, 134, 476, 26, 480, 5, 144, 30, 5535, 18, 51, 36, 28, 224, 92, 25, 104, 4, 226, 65, 16, 38, 1334, 88, 12, 16, 283, 5, 16, 4472, 113, 103, 32, 15, 16, 5345, 19, 178, 32]

फिल्म समीक्षा अलग-अलग लंबाई हो सकता है। नीचे दिए गए कोड को पहले और दूसरे समीक्षा में शब्दों की संख्या को दर्शाता है। के बाद से एक तंत्रिका नेटवर्क के लिए आदानों एक ही लंबाई होना चाहिए, हम इस पर बाद में इसका समाधान करना होगा।

 len(pp_train_data[0]), len(pp_train_data[1])
 
(218, 189)

शब्द को पूर्णांक कन्वर्ट वापस

यह पता है कि कैसे पूर्णांकों इसी पाठ करने के लिए वापस परिवर्तित करने के लिए उपयोगी हो सकता है। यहाँ, हम है कि स्ट्रिंग मानचित्रण के लिए पूर्णांक शामिल एक शब्दकोश वस्तु क्वेरी करने के लिए एक सहायक समारोह बना देंगे:

 def build_reverse_word_index():
  # A dictionary mapping words to an integer index
  word_index = imdb.get_word_index()

  # The first indices are reserved
  word_index = {k: (v + 3) for k, v in word_index.items()}
  word_index['<PAD>'] = 0
  word_index['<START>'] = 1
  word_index['<UNK>'] = 2  # unknown
  word_index['<UNUSED>'] = 3
  return dict((value, key) for (key, value) in word_index.items())

reverse_word_index = build_reverse_word_index()

def decode_review(text):
  return ' '.join([reverse_word_index.get(i, '?') for i in text])
 
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/imdb_word_index.json
1646592/1641221 [==============================] - 0s 0us/step

अब हम उपयोग कर सकते हैं decode_review समीक्षा करने के पहले पाठ प्रदर्शित करने समारोह:

 decode_review(pp_train_data[0])
 
"<START> this film was just brilliant casting location scenery story direction everyone's really suited the part they played and you could just imagine being there robert <UNK> is an amazing actor and now the same being director <UNK> father came from the same scottish island as myself so i loved the fact there was a real connection with this film the witty remarks throughout the film were great it was just brilliant so much that i bought the film as soon as it was released for <UNK> and would recommend it to everyone to watch and the fly fishing was amazing really cried at the end it was so sad and you know what they say if you cry at a film it must have been good and this definitely was also <UNK> to the two little boy's that played the <UNK> of norman and paul they were just brilliant children are often left out of the <UNK> list i think because the stars that play them all grown up are such a big profile for the whole film but these children are amazing and should be praised for what they have done don't you think the whole story was so lovely because it was true and was someone's life after all that was shared with us all"

ग्राफ़ निर्माण

ग्राफ़ निर्माण पाठ नमूनों के लिए embeddings बनाने और फिर embeddings तुलना करने के लिए एक समानता समारोह का उपयोग कर शामिल है।

आगे बढ़ने से पहले, हम पहले इस ट्यूटोरियल द्वारा बनाई गई कलाकृतियों स्टोर करने के लिए एक निर्देशिका बनाने।

mkdir -p /tmp/imdb

नमूना embeddings बनाएं

हम pretrained फिरकी embeddings प्रयोग embeddings बनाने के लिए होगा tf.train.Example इनपुट में प्रत्येक नमूने के लिए प्रारूप। हम में जिसके परिणामस्वरूप embeddings स्टोर करेगा TFRecord एक अतिरिक्त विशेषता यह है कि प्रत्येक नमूने की आईडी का प्रतिनिधित्व करता है के साथ प्रारूप। यह महत्वपूर्ण है और हमें ग्राफ में इसी नोड्स बाद में साथ नमूना embeddings से मेल की अनुमति देगा।

 pretrained_embedding = 'https://  tfhub.dev  /google/tf2-preview/gnews-swivel-20dim/1'

hub_layer = hub.KerasLayer(
    pretrained_embedding, input_shape=[], dtype=tf.string, trainable=True)
 
 def _int64_feature(value):
  """Returns int64 tf.train.Feature."""
  return tf.train.Feature(int64_list=tf.train.Int64List(value=value.tolist()))


def _bytes_feature(value):
  """Returns bytes tf.train.Feature."""
  return tf.train.Feature(
      bytes_list=tf.train.BytesList(value=[value.encode('utf-8')]))


def _float_feature(value):
  """Returns float tf.train.Feature."""
  return tf.train.Feature(float_list=tf.train.FloatList(value=value.tolist()))


def create_embedding_example(word_vector, record_id):
  """Create tf.Example containing the sample's embedding and its ID."""

  text = decode_review(word_vector)

  # Shape = [batch_size,].
  sentence_embedding = hub_layer(tf.reshape(text, shape=[-1,]))

  # Flatten the sentence embedding back to 1-D.
  sentence_embedding = tf.reshape(sentence_embedding, shape=[-1])

  features = {
      'id': _bytes_feature(str(record_id)),
      'embedding': _float_feature(sentence_embedding.numpy())
  }
  return tf.train.Example(features=tf.train.Features(feature=features))


def create_embeddings(word_vectors, output_path, starting_record_id):
  record_id = int(starting_record_id)
  with tf.io.TFRecordWriter(output_path) as writer:
    for word_vector in word_vectors:
      example = create_embedding_example(word_vector, record_id)
      record_id = record_id + 1
      writer.write(example.SerializeToString())
  return record_id


# Persist TF.Example features containing embeddings for training data in
# TFRecord format.
create_embeddings(pp_train_data, '/tmp/imdb/embeddings.tfr', 0)
 
25000

एक ग्राफ का निर्माण

अब हम नमूना embeddings है, हम उन्हें इस्तेमाल करते हैं, एक समानता ग्राफ निर्माण करने के लिए इस ग्राफ में यानी, इस ग्राफ में नोड्स के नमूने और किनारों के अनुरूप होगा नोड्स के जोड़े के बीच समानता के अनुरूप होगा।

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

 nsl.tools.build_graph(['/tmp/imdb/embeddings.tfr'],
                      '/tmp/imdb/graph_99.tsv',
                      similarity_threshold=0.99)
 

नमूना सुविधाओं

हम का उपयोग कर हमारी समस्या के लिए नमूना विशेषताएं बनाने tf.train.Example प्रारूप और उन में जारी रहती है TFRecord प्रारूप। प्रत्येक नमूने निम्नलिखित तीन सुविधाओं में शामिल होंगे:

  1. आईडी: नमूने के नोड आईडी।
  2. शब्द: एक int64 शब्द आईडी युक्त सूची।
  3. लेबल: समीक्षा का लक्ष्य वर्ग की पहचान करने int64 एक सिंगलटन।
 def create_example(word_vector, label, record_id):
  """Create tf.Example containing the sample's word vector, label, and ID."""
  features = {
      'id': _bytes_feature(str(record_id)),
      'words': _int64_feature(np.asarray(word_vector)),
      'label': _int64_feature(np.asarray([label])),
  }
  return tf.train.Example(features=tf.train.Features(feature=features))

def create_records(word_vectors, labels, record_path, starting_record_id):
  record_id = int(starting_record_id)
  with tf.io.TFRecordWriter(record_path) as writer:
    for word_vector, label in zip(word_vectors, labels):
      example = create_example(word_vector, label, record_id)
      record_id = record_id + 1
      writer.write(example.SerializeToString())
  return record_id

# Persist TF.Example features (word vectors and labels) for training and test
# data in TFRecord format.
next_record_id = create_records(pp_train_data, pp_train_labels,
                                '/tmp/imdb/train_data.tfr', 0)
create_records(pp_test_data, pp_test_labels, '/tmp/imdb/test_data.tfr',
               next_record_id)
 
50000

ग्राफ पड़ोसियों के साथ बढ़ाने प्रशिक्षण डेटा

जब से हम नमूना सुविधाओं और संश्लेषित ग्राफ है, हम तंत्रिका संरचित सीखने के लिए संवर्धित प्रशिक्षण डेटा उत्पन्न कर सकते हैं। NSL ढांचे ग्राफ गठबंधन करने के लिए एक पुस्तकालय प्रदान करता है और नमूना ग्राफ नियमितीकरण के लिए अंतिम प्रशिक्षण डेटा उत्पन्न करने के सुविधाएँ। जिसके परिणामस्वरूप प्रशिक्षण डेटा मूल नमूना सुविधाओं के साथ ही उनके इसी पड़ोसियों की विशेषताओं में शामिल होगा।

इस ट्यूटोरियल में, हम अनिर्दिष्ट किनारों पर विचार करने और ग्राफ पड़ोसियों के साथ बढ़ाने प्रशिक्षण आंकड़ों के नमूना प्रति 3 पड़ोसियों की एक अधिकतम उपयोग करें।

 nsl.tools.pack_nbrs(
    '/tmp/imdb/train_data.tfr',
    '',
    '/tmp/imdb/graph_99.tsv',
    '/tmp/imdb/nsl_train_data.tfr',
    add_undirected_edges=True,
    max_nbrs=3)
 

बेस मॉडल

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

सार्वत्रिक चर

 NBR_FEATURE_PREFIX = 'NL_nbr_'
NBR_WEIGHT_SUFFIX = '_weight'
 

Hyperparameters

हम का एक उदाहरण का उपयोग करेगा HParams विभिन्न hyperparameters और स्थिरांक प्रशिक्षण और मूल्यांकन के लिए इस्तेमाल किया inclue करने के लिए। हम संक्षेप में नीचे उनमें से प्रत्येक का वर्णन:

  • num_classes: - सकारात्मक और नकारात्मक वहाँ 2 वर्ग हैं।

  • max_seq_length: यह इस उदाहरण में प्रत्येक फिल्म समीक्षा से माना शब्दों की अधिकतम संख्या है।

  • vocab_size: इस शब्दावली इस उदाहरण के लिए विचार का आकार है।

  • distance_type: इस दूरी मीट्रिक अपने पड़ोसियों के साथ नमूना को नियमित करने के लिए प्रयोग किया जाता है।

  • graph_regularization_multiplier: यह नियंत्रण कुल नुकसान समारोह में ग्राफ नियमितीकरण अवधि के सापेक्ष वजन।

  • num_neighbors: ग्राफ नियमितीकरण के लिए इस्तेमाल किया पड़ोसियों की संख्या। इस मान से कम या ज्यादा के बराबर हो गया है max_nbrs जब लागू, ऊपर उपयोग तर्क nsl.tools.pack_nbrs

  • num_fc_units: तंत्रिका नेटवर्क का पूरी तरह से जुड़ा हुआ परत में पुस्तकों की संख्या।

  • train_epochs: प्रशिक्षण अवधियों की संख्या।

  • batch_size: बैच आकार प्रशिक्षण और मूल्यांकन के लिए इस्तेमाल किया।

  • eval_steps: मूल्यांकन deeming से पहले की प्रक्रिया के लिए बैचों की संख्या पूरी हो चुकी है। तो करने के लिए सेट None , परीक्षण सेट में सभी उदाहरणों मूल्यांकन किया जाता है।

 class HParams(object):
  """Hyperparameters used for training."""
  def __init__(self):
    ### dataset parameters
    self.num_classes = 2
    self.max_seq_length = 256
    self.vocab_size = 10000
    ### neural graph learning parameters
    self.distance_type = nsl.configs.DistanceType.L2
    self.graph_regularization_multiplier = 0.1
    self.num_neighbors = 2
    ### model architecture
    self.num_embedding_dims = 16
    self.num_lstm_dims = 64
    self.num_fc_units = 64
    ### training parameters
    self.train_epochs = 10
    self.batch_size = 128
    ### eval parameters
    self.eval_steps = None  # All instances in the test set are evaluated.

HPARAMS = HParams()
 

डेटा तैयार

समीक्षा-के एरे पूर्णांकों-चाहिए तंत्रिका नेटवर्क में खिलाया जा रहा से पहले tensors के लिए परिवर्तित किया जा। इस रूपांतरण कई तरीकों से किया जा सकता है:

  • की वैक्टर में सरणियों कन्वर्ट 0 और 1 शब्द घटना, एक एक गर्म एन्कोडिंग के लिए इसी तरह का संकेत है। उदाहरण के लिए, अनुक्रम [3, 5] एक बन जाएगा 10000 आयामी सदिश सूचकांक को छोड़कर सभी शून्य है कि 3 और 5 , जो होते हैं। फिर, यह हमारे में पहली परत बनाने के नेटवर्क-एक Dense परत-उस बिंदु वेक्टर डेटा चल संभाल कर सकते हैं। यह दृष्टिकोण एक की आवश्यकता होती है, स्मृति-गहन है, हालांकि num_words * num_reviews आकार मैट्रिक्स।

  • वैकल्पिक रूप से, हम पैड सरणियों तो वे सभी एक ही लंबाई है, तो आकार के एक पूर्णांक टेन्सर बना सकते हैं max_length * num_reviews । हम एक एम्बेडिंग परत हमारे नेटवर्क में पहली परत के रूप में इस आकार से निपटने में सक्षम उपयोग कर सकते हैं।

इस ट्यूटोरियल में, हम दूसरा दृष्टिकोण का प्रयोग करेंगे।

चूंकि फिल्म समीक्षा एक ही लंबाई होना चाहिए, हम का उपयोग करेगा pad_sequence लंबाई मानकीकृत करने के लिए समारोह नीचे परिभाषित।

 def make_dataset(file_path, training=False):
  """Creates a `tf.data.TFRecordDataset`.

  Args:
    file_path: Name of the file in the `.tfrecord` format containing
      `tf.train.Example` objects.
    training: Boolean indicating if we are in training mode.

  Returns:
    An instance of `tf.data.TFRecordDataset` containing the `tf.train.Example`
    objects.
  """

  def pad_sequence(sequence, max_seq_length):
    """Pads the input sequence (a `tf.SparseTensor`) to `max_seq_length`."""
    pad_size = tf.maximum([0], max_seq_length - tf.shape(sequence)[0])
    padded = tf.concat(
        [sequence.values,
         tf.fill((pad_size), tf.cast(0, sequence.dtype))],
        axis=0)
    # The input sequence may be larger than max_seq_length. Truncate down if
    # necessary.
    return tf.slice(padded, [0], [max_seq_length])

  def parse_example(example_proto):
    """Extracts relevant fields from the `example_proto`.

    Args:
      example_proto: An instance of `tf.train.Example`.

    Returns:
      A pair whose first value is a dictionary containing relevant features
      and whose second value contains the ground truth labels.
    """
    # The 'words' feature is a variable length word ID vector.
    feature_spec = {
        'words': tf.io.VarLenFeature(tf.int64),
        'label': tf.io.FixedLenFeature((), tf.int64, default_value=-1),
    }
    # We also extract corresponding neighbor features in a similar manner to
    # the features above during training.
    if training:
      for i in range(HPARAMS.num_neighbors):
        nbr_feature_key = '{}{}_{}'.format(NBR_FEATURE_PREFIX, i, 'words')
        nbr_weight_key = '{}{}{}'.format(NBR_FEATURE_PREFIX, i,
                                         NBR_WEIGHT_SUFFIX)
        feature_spec[nbr_feature_key] = tf.io.VarLenFeature(tf.int64)

        # We assign a default value of 0.0 for the neighbor weight so that
        # graph regularization is done on samples based on their exact number
        # of neighbors. In other words, non-existent neighbors are discounted.
        feature_spec[nbr_weight_key] = tf.io.FixedLenFeature(
            [1], tf.float32, default_value=tf.constant([0.0]))

    features = tf.io.parse_single_example(example_proto, feature_spec)

    # Since the 'words' feature is a variable length word vector, we pad it to a
    # constant maximum length based on HPARAMS.max_seq_length
    features['words'] = pad_sequence(features['words'], HPARAMS.max_seq_length)
    if training:
      for i in range(HPARAMS.num_neighbors):
        nbr_feature_key = '{}{}_{}'.format(NBR_FEATURE_PREFIX, i, 'words')
        features[nbr_feature_key] = pad_sequence(features[nbr_feature_key],
                                                 HPARAMS.max_seq_length)

    labels = features.pop('label')
    return features, labels

  dataset = tf.data.TFRecordDataset([file_path])
  if training:
    dataset = dataset.shuffle(10000)
  dataset = dataset.map(parse_example)
  dataset = dataset.batch(HPARAMS.batch_size)
  return dataset


train_dataset = make_dataset('/tmp/imdb/nsl_train_data.tfr', True)
test_dataset = make_dataset('/tmp/imdb/test_data.tfr')
 

मॉडल का निर्माण

एक तंत्रिका नेटवर्क stacking द्वारा बनाई गई है परतों-यह दो मुख्य स्थापत्य निर्णय की आवश्यकता है:

  • कितनी परतें मॉडल में उपयोग करने के लिए?
  • कितने छिपा इकाइयों प्रत्येक परत के लिए उपयोग करने के लिए?

इस उदाहरण में, इनपुट डेटा शब्द-सूचकांक की एक सरणी के होते हैं। लेबल भविष्यवाणी करने के लिए या तो 0 या 1 है।

हम इस ट्यूटोरियल में हमारे बेस मॉडल के रूप में एक दो-तरफा LSTM का प्रयोग करेंगे।

 # This function exists as an alternative to the bi-LSTM model used in this
# notebook.
def make_feed_forward_model():
  """Builds a simple 2 layer feed forward neural network."""
  inputs = tf.keras.Input(
      shape=(HPARAMS.max_seq_length,), dtype='int64', name='words')
  embedding_layer = tf.keras.layers.Embedding(HPARAMS.vocab_size, 16)(inputs)
  pooling_layer = tf.keras.layers.GlobalAveragePooling1D()(embedding_layer)
  dense_layer = tf.keras.layers.Dense(16, activation='relu')(pooling_layer)
  outputs = tf.keras.layers.Dense(1, activation='sigmoid')(dense_layer)
  return tf.keras.Model(inputs=inputs, outputs=outputs)


def make_bilstm_model():
  """Builds a bi-directional LSTM model."""
  inputs = tf.keras.Input(
      shape=(HPARAMS.max_seq_length,), dtype='int64', name='words')
  embedding_layer = tf.keras.layers.Embedding(HPARAMS.vocab_size,
                                              HPARAMS.num_embedding_dims)(
                                                  inputs)
  lstm_layer = tf.keras.layers.Bidirectional(
      tf.keras.layers.LSTM(HPARAMS.num_lstm_dims))(
          embedding_layer)
  dense_layer = tf.keras.layers.Dense(
      HPARAMS.num_fc_units, activation='relu')(
          lstm_layer)
  outputs = tf.keras.layers.Dense(1, activation='sigmoid')(dense_layer)
  return tf.keras.Model(inputs=inputs, outputs=outputs)


# Feel free to use an architecture of your choice.
model = make_bilstm_model()
model.summary()
 
Model: "functional_1"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
words (InputLayer)           [(None, 256)]             0         
_________________________________________________________________
embedding (Embedding)        (None, 256, 16)           160000    
_________________________________________________________________
bidirectional (Bidirectional (None, 128)               41472     
_________________________________________________________________
dense (Dense)                (None, 64)                8256      
_________________________________________________________________
dense_1 (Dense)              (None, 1)                 65        
=================================================================
Total params: 209,793
Trainable params: 209,793
Non-trainable params: 0
_________________________________________________________________

परतों को प्रभावी ढंग से वर्गीकारक निर्माण करने के लिए क्रमिक रूप से खड़ी दिखती हैं:

  1. पहली परत एक है Input परत जो पूर्णांक एन्कोड शब्दावली लेता है।
  2. अगले परत एक है Embedding परत है, जो पूर्णांक एन्कोड शब्दावली और दिखता है ऊपर प्रत्येक शब्द सूचकांक के लिए एम्बेडिंग वेक्टर लेता है। ये वाहक मॉडल ट्रेन के रूप में सीखा रहे हैं। वैक्टर उत्पादन सरणी के लिए एक आयाम जोड़ें। जिसके परिणामस्वरूप आयाम हैं: (batch, sequence, embedding)
  3. इसके बाद, एक द्विदिश LSTM परत प्रत्येक उदाहरण के लिए एक निश्चित लंबाई उत्पादन वेक्टर देता है।
  4. यह निश्चित लंबाई उत्पादन वेक्टर एक पूरी तरह से जुड़ा हुआ (के माध्यम से पहुंचाया जाता है Dense 64 छिपा इकाइयों के साथ) परत।
  5. आखिरी परत घनी एक भी उत्पादन नोड के साथ जुड़ा हुआ है। का उपयोग करते हुए sigmoid सक्रियण समारोह, यह मान एक संभावना है, या आत्मविश्वास का स्तर का प्रतिनिधित्व करने, 0 और 1 के बीच एक नाव है।

छिपे हुए इकाइयों

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

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

घटाने समारोह और अनुकूलक

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

 model.compile(
    optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
 

एक सत्यापन समूह बनाना होगा

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

इस ट्यूटोरियल में, हम प्रशिक्षण के लिए लेबल डेटा और मान्यता डेटा के रूप में रहती है जबकि वे प्रारंभिक प्रशिक्षण के नमूनों की लगभग 10% (25000 का 10%) ले लो। चूंकि प्रारंभ ट्रेन / परीक्षण विभाजन 50/50 था (25000 नमूने प्रत्येक), प्रभावी ट्रेन / सत्यापन / परीक्षण विभाजित अब हमारे पास 5/45/50 है।

ध्यान दें कि 'train_dataset' पहले से ही batched किया गया है और फेरबदल।

 validation_fraction = 0.9
validation_size = int(validation_fraction *
                      int(training_samples_count / HPARAMS.batch_size))
print(validation_size)
validation_dataset = train_dataset.take(validation_size)
train_dataset = train_dataset.skip(validation_size)
 
175

मॉडल ट्रेन

मिनी बैचों में मॉडल ट्रेन। जबकि प्रशिक्षण, मॉडल की हार और सत्यापन सेट पर सटीकता की निगरानी:

 history = model.fit(
    train_dataset,
    validation_data=validation_dataset,
    epochs=HPARAMS.train_epochs,
    verbose=1)
 
Epoch 1/10

/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/engine/functional.py:543: UserWarning: Input dict contained keys ['NL_nbr_0_words', 'NL_nbr_1_words', 'NL_nbr_0_weight', 'NL_nbr_1_weight'] which did not match any model input. They will be ignored by the model.
  [n for n in tensors.keys() if n not in ref_input_names])

21/21 [==============================] - 19s 925ms/step - loss: 0.6930 - accuracy: 0.5092 - val_loss: 0.6924 - val_accuracy: 0.5006
Epoch 2/10
21/21 [==============================] - 19s 894ms/step - loss: 0.6890 - accuracy: 0.5465 - val_loss: 0.7294 - val_accuracy: 0.5698
Epoch 3/10
21/21 [==============================] - 19s 883ms/step - loss: 0.6785 - accuracy: 0.6208 - val_loss: 0.6489 - val_accuracy: 0.7043
Epoch 4/10
21/21 [==============================] - 19s 890ms/step - loss: 0.6592 - accuracy: 0.6400 - val_loss: 0.6523 - val_accuracy: 0.6866
Epoch 5/10
21/21 [==============================] - 19s 883ms/step - loss: 0.6413 - accuracy: 0.6923 - val_loss: 0.6335 - val_accuracy: 0.7004
Epoch 6/10
21/21 [==============================] - 21s 982ms/step - loss: 0.6053 - accuracy: 0.7188 - val_loss: 0.5716 - val_accuracy: 0.7183
Epoch 7/10
21/21 [==============================] - 18s 879ms/step - loss: 0.5204 - accuracy: 0.7619 - val_loss: 0.4511 - val_accuracy: 0.7930
Epoch 8/10
21/21 [==============================] - 19s 882ms/step - loss: 0.4719 - accuracy: 0.7758 - val_loss: 0.4244 - val_accuracy: 0.8094
Epoch 9/10
21/21 [==============================] - 18s 880ms/step - loss: 0.3695 - accuracy: 0.8431 - val_loss: 0.3567 - val_accuracy: 0.8487
Epoch 10/10
21/21 [==============================] - 19s 891ms/step - loss: 0.3504 - accuracy: 0.8500 - val_loss: 0.3219 - val_accuracy: 0.8652

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

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

 results = model.evaluate(test_dataset, steps=HPARAMS.eval_steps)
print(results)
 
196/196 [==============================] - 17s 85ms/step - loss: 0.4116 - accuracy: 0.8221
[0.4116455018520355, 0.8221200108528137]

समय के साथ सटीकता / हानि का ग्राफ बनाएं

model.fit() की ओर से एक History उद्देश्य यह है कि सब कुछ है कि प्रशिक्षण के दौरान हुआ के साथ एक शब्दकोश में शामिल है:

 history_dict = history.history
history_dict.keys()
 
dict_keys(['loss', 'accuracy', 'val_loss', 'val_accuracy'])

चार प्रविष्टियों हैं: प्रत्येक के लिए एक प्रशिक्षण और सत्यापन के दौरान मीट्रिक नजर रखी। हम तुलना के लिए प्रशिक्षण और मान्यता नुकसान है, साथ ही प्रशिक्षण और मान्यता सटीकता प्लॉट करने के लिए इन का उपयोग कर सकते हैं:

 acc = history_dict['accuracy']
val_acc = history_dict['val_accuracy']
loss = history_dict['loss']
val_loss = history_dict['val_loss']

epochs = range(1, len(acc) + 1)

# "-r^" is for solid red line with triangle markers.
plt.plot(epochs, loss, '-r^', label='Training loss')
# "-b0" is for solid blue line with circle markers.
plt.plot(epochs, val_loss, '-bo', label='Validation loss')
plt.title('Training and validation loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend(loc='best')

plt.show()
 

png

 plt.clf()   # clear figure

plt.plot(epochs, acc, '-r^', label='Training acc')
plt.plot(epochs, val_acc, '-bo', label='Validation acc')
plt.title('Training and validation accuracy')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend(loc='best')

plt.show()
 

png

सूचना प्रशिक्षण नुकसान प्रत्येक युग और प्रत्येक युग के साथ प्रशिक्षण सटीकता वृद्धि के साथ कम हो जाती है। यह आशा की जाती है जब एक ढाल वंश का उपयोग कर अनुकूलन-यह हर यात्रा पर वांछित मात्रा को कम करना चाहिए।

ग्राफ़ नियमितीकरण

अब हम बेस मॉडल है कि हम ऊपर बनाया का उपयोग कर ग्राफ नियमितीकरण की कोशिश करने के लिए तैयार हैं। हम का उपयोग करेगा GraphRegularization आवरण तंत्रिका संरचित सीखने ढांचे आधार (द्वि-LSTM) मॉडल रैप करने के लिए ग्राफ नियमितीकरण शामिल करने के लिए द्वारा प्रदान की कक्षा। प्रशिक्षण और ग्राफ को नियमित मॉडल के मूल्यांकन के लिए चरणों के बाकी बेस मॉडल के समान हैं।

ग्राफ-नियमित मॉडल बनाएं

ग्राफ नियमितीकरण के वृद्धिशील लाभ का आकलन करने के लिए, हम एक नया बेस मॉडल उदाहरण पैदा करेगा। इसका कारण यह है है model पहले से ही कुछ पुनरावृत्तियों के लिए प्रशिक्षित किया गया है, और इस प्रशिक्षित मॉडल पुन: उपयोग एक ग्राफ-नियमित मॉडल बनाने के लिए के लिए एक निष्पक्ष तुलना नहीं होगा model

 # Build a new base LSTM model.
base_reg_model = make_bilstm_model()
 
 # Wrap the base model with graph regularization.
graph_reg_config = nsl.configs.make_graph_reg_config(
    max_neighbors=HPARAMS.num_neighbors,
    multiplier=HPARAMS.graph_regularization_multiplier,
    distance_type=HPARAMS.distance_type,
    sum_over_axis=-1)
graph_reg_model = nsl.keras.GraphRegularization(base_reg_model,
                                                graph_reg_config)
graph_reg_model.compile(
    optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
 

मॉडल ट्रेन

 graph_reg_history = graph_reg_model.fit(
    train_dataset,
    validation_data=validation_dataset,
    epochs=HPARAMS.train_epochs,
    verbose=1)
 
Epoch 1/10

/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/framework/indexed_slices.py:432: UserWarning: Converting sparse IndexedSlices to a dense Tensor of unknown shape. This may consume a large amount of memory.
  "Converting sparse IndexedSlices to a dense Tensor of unknown shape. "

21/21 [==============================] - 22s 1s/step - loss: 0.6930 - accuracy: 0.5246 - scaled_graph_loss: 2.9800e-06 - val_loss: 0.6929 - val_accuracy: 0.4998
Epoch 2/10
21/21 [==============================] - 21s 988ms/step - loss: 0.6909 - accuracy: 0.5200 - scaled_graph_loss: 7.8452e-06 - val_loss: 0.6838 - val_accuracy: 0.5917
Epoch 3/10
21/21 [==============================] - 21s 980ms/step - loss: 0.6656 - accuracy: 0.6277 - scaled_graph_loss: 6.1205e-04 - val_loss: 0.6591 - val_accuracy: 0.6905
Epoch 4/10
21/21 [==============================] - 21s 981ms/step - loss: 0.6395 - accuracy: 0.6846 - scaled_graph_loss: 0.0016 - val_loss: 0.5860 - val_accuracy: 0.7171
Epoch 5/10
21/21 [==============================] - 21s 980ms/step - loss: 0.5388 - accuracy: 0.7573 - scaled_graph_loss: 0.0043 - val_loss: 0.4910 - val_accuracy: 0.7844
Epoch 6/10
21/21 [==============================] - 21s 989ms/step - loss: 0.4105 - accuracy: 0.8281 - scaled_graph_loss: 0.0146 - val_loss: 0.3353 - val_accuracy: 0.8612
Epoch 7/10
21/21 [==============================] - 21s 986ms/step - loss: 0.3416 - accuracy: 0.8681 - scaled_graph_loss: 0.0203 - val_loss: 0.4134 - val_accuracy: 0.8209
Epoch 8/10
21/21 [==============================] - 21s 981ms/step - loss: 0.4230 - accuracy: 0.8273 - scaled_graph_loss: 0.0144 - val_loss: 0.4755 - val_accuracy: 0.7696
Epoch 9/10
21/21 [==============================] - 22s 1s/step - loss: 0.4905 - accuracy: 0.7950 - scaled_graph_loss: 0.0080 - val_loss: 0.3862 - val_accuracy: 0.8382
Epoch 10/10
21/21 [==============================] - 21s 978ms/step - loss: 0.3384 - accuracy: 0.8754 - scaled_graph_loss: 0.0215 - val_loss: 0.3002 - val_accuracy: 0.8811

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

 graph_reg_results = graph_reg_model.evaluate(test_dataset, steps=HPARAMS.eval_steps)
print(graph_reg_results)
 
196/196 [==============================] - 16s 84ms/step - loss: 0.3852 - accuracy: 0.8301
[0.385225385427475, 0.830079972743988]

समय के साथ सटीकता / हानि का ग्राफ बनाएं

 graph_reg_history_dict = graph_reg_history.history
graph_reg_history_dict.keys()
 
dict_keys(['loss', 'accuracy', 'scaled_graph_loss', 'val_loss', 'val_accuracy'])

वहाँ शब्दकोश में कुल में पांच प्रविष्टियों हैं: प्रशिक्षण में कमी, प्रशिक्षण सटीकता, प्रशिक्षण ग्राफ घटाने, सत्यापन हानि, और मान्यता सटीकता। हम तुलना के लिए सभी को एक साथ उन्हें प्लॉट कर सकते हैं। ध्यान दें कि ग्राफ नुकसान केवल प्रशिक्षण के दौरान की जाती है।

 acc = graph_reg_history_dict['accuracy']
val_acc = graph_reg_history_dict['val_accuracy']
loss = graph_reg_history_dict['loss']
graph_loss = graph_reg_history_dict['scaled_graph_loss']
val_loss = graph_reg_history_dict['val_loss']

epochs = range(1, len(acc) + 1)

plt.clf()   # clear figure

# "-r^" is for solid red line with triangle markers.
plt.plot(epochs, loss, '-r^', label='Training loss')
# "-gD" is for solid green line with diamond markers.
plt.plot(epochs, graph_loss, '-gD', label='Training graph loss')
# "-b0" is for solid blue line with circle markers.
plt.plot(epochs, val_loss, '-bo', label='Validation loss')
plt.title('Training and validation loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend(loc='best')

plt.show()
 

png

 plt.clf()   # clear figure

plt.plot(epochs, acc, '-r^', label='Training acc')
plt.plot(epochs, val_acc, '-bo', label='Validation acc')
plt.title('Training and validation accuracy')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend(loc='best')

plt.show()
 

png

अर्द्ध देखरेख सीखने की शक्ति

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

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

 # Accuracy values for both the Bi-LSTM model and the feed forward NN model have
# been precomputed for the following supervision ratios.

supervision_ratios = [0.3, 0.15, 0.05, 0.03, 0.02, 0.01, 0.005]

model_tags = ['Bi-LSTM model', 'Feed Forward NN model']
base_model_accs = [[84, 84, 83, 80, 65, 52, 50], [87, 86, 76, 74, 67, 52, 51]]
graph_reg_model_accs = [[84, 84, 83, 83, 65, 63, 50],
                        [87, 86, 80, 75, 67, 52, 50]]

plt.clf()  # clear figure

fig, axes = plt.subplots(1, 2)
fig.set_size_inches((12, 5))

for ax, model_tag, base_model_acc, graph_reg_model_acc in zip(
    axes, model_tags, base_model_accs, graph_reg_model_accs):

  # "-r^" is for solid red line with triangle markers.
  ax.plot(base_model_acc, '-r^', label='Base model')
  # "-gD" is for solid green line with diamond markers.
  ax.plot(graph_reg_model_acc, '-gD', label='Graph-regularized model')
  ax.set_title(model_tag)
  ax.set_xlabel('Supervision ratio')
  ax.set_ylabel('Accuracy(%)')
  ax.set_ylim((25, 100))
  ax.set_xticks(range(len(supervision_ratios)))
  ax.set_xticklabels(supervision_ratios)
  ax.legend(loc='best')

plt.show()
 
<Figure size 432x288 with 0 Axes>

png

यह देखा जा सकता है के रूप में superivision अनुपात कम हो जाती है, मॉडल सटीकता भी कम हो जाती है कि। इस मॉडल का इस्तेमाल किया वास्तुकला की परवाह किए बिना दोनों बेस मॉडल के लिए और ग्राफ को नियमित मॉडल के लिए सच है। हालांकि, सूचना है कि ग्राफ-नियमित मॉडल प्रदर्शन दोनों आर्किटेक्चर के लिए बेस मॉडल की तुलना में बेहतर। विशेष रूप से, द्वि-LSTM मॉडल, के लिए जब पर्यवेक्षण अनुपात 0.01 है, ग्राफ-नियमित मॉडल की सटीकता ~ 20% बेस मॉडल की तुलना में अधिक है। यह मुख्य रूप से ग्राफ-नियमित मॉडल है, जहां प्रशिक्षण नमूने के बीच संरचनात्मक समानता प्रशिक्षण नमूने खुद को के अलावा प्रयोग किया जाता है के लिए अर्द्ध देखरेख सीखने की वजह से है।

निष्कर्ष

हम तंत्रिका संरचित लर्निंग (NSL) ढांचे यहाँ तक कि जब इनपुट एक स्पष्ट ग्राफ शामिल नहीं है का उपयोग करते हुए ग्राफ नियमितीकरण के उपयोग का प्रदर्शन किया है। हम IMDB फिल्म समीक्षा जिसके लिए हम समीक्षा embeddings के आधार पर एक समानता ग्राफ संश्लेषित की भावना वर्गीकरण का कार्य माना जाता है। हम उन hyperparameters, पर्यवेक्षण की राशि, अलग से और अलग मॉडल आर्किटेक्चर का उपयोग करके आगे प्रयोग करने के लिए प्रोत्साहित करते हैं।