Google I/O-তে টিউন করার জন্য ধন্যবাদ। চাহিদা অনুযায়ী সব সেশন দেখুন চাহিদা অনুযায়ী দেখুন

সংশ্লেষিত গ্রাফ ব্যবহার করে অনুভূতির শ্রেণিবিন্যাসের জন্য গ্রাফ নিয়মিতকরণ

TensorFlow.org এ দেখুন Google Colab-এ চালান GitHub-এ উৎস দেখুন নোটবুক ডাউনলোড করুন TF হাব মডেল দেখুন

ওভারভিউ

ইতিবাচক বা নেতিবাচক হিসেবে এই নোটবুক শ্রেণী সিনেমা পর্যালোচনা পর্যালোচনার টেক্সট ব্যবহার করে। এই বাইনারি ক্লাসিফিকেশন, মেশিন লার্নিং সমস্যা একটি গুরুত্বপূর্ণ এবং ব্যাপকভাবে প্রযোজ্য ধরনের একটি উদাহরণ।

আমরা প্রদত্ত ইনপুট থেকে একটি গ্রাফ তৈরি করে এই নোটবুকে গ্রাফ নিয়মিতকরণের ব্যবহার প্রদর্শন করব। নিউরাল স্ট্রাকচার্ড লার্নিং (NSL) ফ্রেমওয়ার্ক ব্যবহার করে একটি গ্রাফ-নিয়মিত মডেল তৈরি করার সাধারণ রেসিপি যখন ইনপুটে একটি সুস্পষ্ট গ্রাফ থাকে না তখন নিম্নরূপ:

  1. ইনপুটে প্রতিটি পাঠ্য নমুনার জন্য এম্বেডিং তৈরি করুন। এই যেমন প্রাক প্রশিক্ষিত মডেলগুলি ব্যবহার করা যেতে পারে word2vec , সুইভেল , বার্ট ইত্যাদি
  2. 'L2' দূরত্ব, 'কোসাইন' দূরত্ব ইত্যাদির মতো একটি মিল মেট্রিক ব্যবহার করে এই এমবেডিংয়ের উপর ভিত্তি করে একটি গ্রাফ তৈরি করুন। গ্রাফের নোডগুলি নমুনার সাথে মিলে যায় এবং গ্রাফের প্রান্তগুলি নমুনার জোড়ার মধ্যে মিলের সাথে মিলে যায়৷
  3. উপরের সংশ্লেষিত গ্রাফ এবং নমুনা বৈশিষ্ট্যগুলি থেকে প্রশিক্ষণ ডেটা তৈরি করুন। ফলস্বরূপ প্রশিক্ষণের ডেটাতে মূল নোড বৈশিষ্ট্যগুলি ছাড়াও প্রতিবেশী বৈশিষ্ট্য থাকবে।
  4. কেরাস অনুক্রমিক, কার্যকরী, বা সাবক্লাস API ব্যবহার করে একটি বেস মডেল হিসাবে একটি নিউরাল নেটওয়ার্ক তৈরি করুন।
  5. একটি নতুন গ্রাফ কেরাস মডেল তৈরি করতে NSL ফ্রেমওয়ার্ক দ্বারা প্রদত্ত গ্রাফ রেগুলারাইজেশন র্যাপার ক্লাসের সাথে বেস মডেলটি মুড়ে দিন। এই নতুন মডেলটি তার প্রশিক্ষণের লক্ষ্যে নিয়মিতকরণের শব্দ হিসাবে একটি গ্রাফ নিয়মিতকরণ ক্ষতি অন্তর্ভুক্ত করবে।
  6. গ্রাফ কেরাস মডেলটি প্রশিক্ষণ এবং মূল্যায়ন করুন।

প্রয়োজনীয়তা

  1. নিউরাল স্ট্রাকচার্ড লার্নিং প্যাকেজ ইনস্টল করুন।
  2. টেনসরফ্লো-হাব ইনস্টল করুন।
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.8.0-rc0
Eager mode:  True
Hub version:  0.12.0
GPU is NOT AVAILABLE
2022-01-05 12:28:32.113752: E tensorflow/stream_executor/cuda/cuda_driver.cc:271] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected

আইএমডিবি ডেটাসেট

IMDB, ডেটা সেটটি থেকে 50,000 সিনেমা রিভিউ পাঠ্য ধারণ ইন্টারনেট মুভি ডেটাবেজ । এগুলি প্রশিক্ষণের জন্য 25,000টি পর্যালোচনা এবং পরীক্ষার জন্য 25,000টি পর্যালোচনাতে বিভক্ত। প্রশিক্ষণ ও পরীক্ষা সেট সুষম হয়, অর্থাত তারা ইতিবাচক ও নেতিবাচক রিভিউ একটি সমান সংখ্যা ধারণ করে।

এই টিউটোরিয়ালে, আমরা IMDB ডেটাসেটের একটি প্রি-প্রসেসড সংস্করণ ব্যবহার করব।

প্রিপ্রসেসড আইএমডিবি ডেটাসেট ডাউনলোড করুন

IMDB ডেটাসেট TensorFlow-এর সাথে প্যাকেজ করা হয়। এটি ইতিমধ্যেই প্রিপ্রসেস করা হয়েছে যাতে পর্যালোচনাগুলি (শব্দের ক্রম) পূর্ণসংখ্যার ক্রমগুলিতে রূপান্তরিত হয়েছে, যেখানে প্রতিটি পূর্ণসংখ্যা একটি অভিধানে একটি নির্দিষ্ট শব্দকে উপস্থাপন করে।

নিম্নলিখিত কোডটি 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
17473536/17464789 [==============================] - 0s 0us/step

যুক্তি num_words=10000 প্রশিক্ষণ ডেটা শীর্ষ 10,000 সবচেয়ে বেশিবার যে শব্দ রাখে। শব্দভান্ডারের আকার নিয়ন্ত্রণযোগ্য রাখতে বিরল শব্দগুলি বাতিল করা হয়।

তথ্য অন্বেষণ

আসুন ডেটার বিন্যাসটি বুঝতে একটু সময় নিই। ডেটাসেটটি প্রিপ্রসেস করা হয়: প্রতিটি উদাহরণ হল মুভি রিভিউয়ের শব্দগুলিকে উপস্থাপন করে পূর্ণসংখ্যার একটি অ্যারে। প্রতিটি লেবেল হল 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
1654784/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"

গ্রাফ নির্মাণ

গ্রাফ নির্মাণে পাঠ্য নমুনার জন্য এম্বেডিং তৈরি করা এবং তারপর এম্বেডিং তুলনা করার জন্য একটি মিল ফাংশন ব্যবহার করা জড়িত।

আরও এগিয়ে যাওয়ার আগে, আমরা প্রথমে এই টিউটোরিয়াল দ্বারা তৈরি শিল্পকর্ম সংরক্ষণ করার জন্য একটি ডিরেক্টরি তৈরি করি।

mkdir -p /tmp/imdb

নমুনা এম্বেডিং তৈরি করুন

আমরা pretrained সুইভেল embeddings ব্যবহার embeddings তৈরি করতে হবে tf.train.Example ইনপুট প্রতিটি নমুনা জন্য বিন্যাস। আমরা ফলে embeddings সংরক্ষণ করবে TFRecord একটি অতিরিক্ত বৈশিষ্ট্য প্রতিটি নমুনা আইডি প্রতিনিধিত্ব করে সহ বিন্যাস। এটি গুরুত্বপূর্ণ এবং পরবর্তীতে গ্রাফে সংশ্লিষ্ট নোডগুলির সাথে নমুনা এম্বেডিংগুলিকে মেলাতে আমাদের অনুমতি দেবে৷

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 এবং বিল্ড প্রান্ত তুলনা। এটি আমাদের একটি সাদৃশ্য থ্রেশহোল্ড নির্দিষ্ট করার অনুমতি দেয়, যা চূড়ান্ত গ্রাফ থেকে ভিন্ন প্রান্তগুলি বাতিল করতে ব্যবহার করা যেতে পারে। এই উদাহরণে, সাদৃশ্য থ্রেশহোল্ড হিসাবে 0.99 এবং র্যান্ডম বীজ হিসাবে 12345 ব্যবহার করে, আমরা একটি গ্রাফের সাথে শেষ করি যার 429,415 দ্বি-দিকনির্দেশক প্রান্ত রয়েছে। এখানে আমরা এর জন্য গ্রাফ রচয়িতা সমর্থন ব্যবহার করছেন এলাকার সংবেদনশীল হ্যাশ (LSH) গ্রাফ ভবন গতি বাড়াতে। গ্রাফ রচয়িতা এর LSH সমর্থন ব্যবহার করে বিস্তারিত জানার জন্য দেখুন build_graph_from_config এপিআই ডকুমেন্টেশন।

graph_builder_config = nsl.configs.GraphBuilderConfig(
    similarity_threshold=0.99, lsh_splits=32, lsh_rounds=15, random_seed=12345)
nsl.tools.build_graph_from_config(['/tmp/imdb/embeddings.tfr'],
                                  '/tmp/imdb/graph_99.tsv',
                                  graph_builder_config)

প্রতিটি দ্বি-মুখী প্রান্ত আউটপুট TSV ফাইলে দুটি নির্দেশিত প্রান্ত দ্বারা উপস্থাপিত হয়, যাতে ফাইলটিতে 429,415 * 2 = 858,830টি মোট লাইন রয়েছে:

wc -l /tmp/imdb/graph_99.tsv
858830 /tmp/imdb/graph_99.tsv

নমুনা বৈশিষ্ট্য

আমরা ব্যবহার আমাদের সমস্যা জন্য নমুনা বৈশিষ্ট্য তৈরি tf.train.Example বিন্যাস এবং তাদের মধ্যে জিদ TFRecord বিন্যাস। প্রতিটি নমুনা নিম্নলিখিত তিনটি বৈশিষ্ট্য অন্তর্ভুক্ত করবে:

  1. আইডি: নমুনা নোড আইডি।
  2. শব্দ: একটি int64 শব্দ ID- র ধারণকারী তালিকা।
  3. ট্যাগ: পর্যালোচনার লক্ষ্য বর্গ চিহ্নিতকরণের int64 একটি Singleton।
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)

বেস মডেল

আমরা এখন গ্রাফ নিয়মিতকরণ ছাড়া একটি বেস মডেল তৈরি করতে প্রস্তুত। এই মডেলটি তৈরি করার জন্য, আমরা হয় এম্বেডিংগুলি ব্যবহার করতে পারি যা গ্রাফ তৈরিতে ব্যবহৃত হয়েছিল, অথবা আমরা শ্রেণীবিভাগের কাজের সাথে যৌথভাবে নতুন এমবেডিং শিখতে পারি। এই নোটবুকের উদ্দেশ্যে, আমরা পরেরটি করব।

গ্লোবাল ভেরিয়েবল

NBR_FEATURE_PREFIX = 'NL_nbr_'
NBR_WEIGHT_SUFFIX = '_weight'

হাইপারপ্যারামিটার

আমরা একটি দৃষ্টান্ত ব্যবহার করবে HParams বিভিন্ন hyperparameters এবং ধ্রুবক প্রশিক্ষণ ও পরীক্ষা নিরীক্ষার জন্য ব্যবহৃত inclue করতে। আমরা নীচে তাদের প্রতিটি সংক্ষিপ্তভাবে বর্ণনা করি:

  • num_classes: - ধনাত্মক এবং ঋণাত্মক এখানে আছে 2 শ্রেণীর হয়।

  • max_seq_length এই এই উদাহরণে প্রতিটি সিনেমা পর্যালোচনা থেকে বিবেচনা শব্দের সর্বোচ্চ সংখ্যা হল।

  • vocab_size এই শব্দভান্ডার এই উদাহরণে জন্য বিবেচনা মাপ।

  • distance_type এই দূরত্ব মেট্রিক তার প্রতিবেশীদের সঙ্গে নমুনা নিয়মিত করার ব্যবহার করা হয়।

  • graph_regularization_multiplier এই নিয়ন্ত্রণ সামগ্রিক ক্ষয় ফাংশনে গ্রাফ নিয়মিতকরণ শব্দটি আপেক্ষিক ওজন।

  • num_neighbors: গ্রাফ নিয়মিতকরণ জন্য ব্যবহৃত প্রতিবেশীদের সংখ্যা। এই মান এর চেয়ে বড় বা কম সমান হতে হয়েছে max_nbrs যখন invoking উপরে ব্যবহৃত যুক্তি 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()

ডেটা প্রস্তুত করুন

নিউরাল নেটওয়ার্কে খাওয়ানোর আগে পর্যালোচনাগুলি-পূর্ণসংখ্যার অ্যারেগুলিকে অবশ্যই টেনসরে রূপান্তর করতে হবে। এই রূপান্তরটি কয়েকটি উপায়ে করা যেতে পারে:

  • এর ভেক্টর মধ্যে অ্যারে রূপান্তর করুন 0 s এবং 1 শব্দ সংঘটন, একটি এক-গরম এনকোডিং অনুরূপ ইঙ্গিত গুলি। উদাহরণস্বরূপ, ক্রম [3, 5] একটি হয়ে 10000 -dimensional ভেক্টর সূচকের ছাড়া সব zeros যে 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')

মডেল তৈরি করুন

একটি নিউরাল নেটওয়ার্ক স্তরগুলিকে স্ট্যাকিং করে তৈরি করা হয় - এর জন্য দুটি প্রধান স্থাপত্যগত সিদ্ধান্তের প্রয়োজন হয়:

  • মডেলে কয়টি স্তর ব্যবহার করতে হবে?
  • কত গোপন ইউনিট প্রতিটি স্তরের ব্যবহার করতে হয়?

এই উদাহরণে, ইনপুট ডেটা শব্দ-সূচকের একটি অ্যারে নিয়ে গঠিত। ভবিষ্যদ্বাণী করার জন্য লেবেলগুলি হয় 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)(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)(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: "model"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 words (InputLayer)          [(None, 256)]             0         
                                                                 
 embedding (Embedding)       (None, 256, 16)           160000    
                                                                 
 bidirectional (Bidirectiona  (None, 128)              41472     
 l)                                                              
                                                                 
 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 স্তর। আউটপুট সংখ্যা (ইউনিট, নোড, বা নিউরন) হল স্তরের প্রতিনিধিত্বমূলক স্থানের মাত্রা। অন্য কথায়, একটি অভ্যন্তরীণ প্রতিনিধিত্ব শেখার সময় নেটওয়ার্কে যে পরিমাণ স্বাধীনতা দেওয়া হয়।

যদি একটি মডেলের আরও লুকানো ইউনিট (একটি উচ্চ-মাত্রিক উপস্থাপনা স্থান), এবং/অথবা আরও স্তর থাকে, তাহলে নেটওয়ার্ক আরও জটিল উপস্থাপনা শিখতে পারে। যাইহোক, এটি নেটওয়ার্কটিকে কম্পিউটেশনালভাবে আরও ব্যয়বহুল করে তোলে এবং অবাঞ্ছিত প্যাটার্ন শেখার দিকে পরিচালিত করতে পারে-প্যাটার্ন যা প্রশিক্ষণের ডেটাতে কর্মক্ষমতা উন্নত করে কিন্তু পরীক্ষার ডেটাতে নয়। এই overfitting বলা হয়।

ক্ষতি ফাংশন এবং অপ্টিমাইজার

একটি মডেল একটি ক্ষতি ফাংশন এবং প্রশিক্ষণের জন্য একটি অপ্টিমাইজার প্রয়োজন. যেহেতু এই একটি বাইনারি শ্রেণীবিন্যাস সমস্যা এবং সম্ভাবনা আউটপুট মডেল (ক সিগমা অ্যাক্টিভেশন সঙ্গে একটি একক ইউনিট স্তর), আমরা ব্যবহার করব binary_crossentropy ক্ষতি ফাংশন।

model.compile(
    optimizer='adam',
    loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),
    metrics=['accuracy'])

একটি বৈধতা সেট তৈরি করুন

প্রশিক্ষণের সময়, আমরা ডেটার মডেলের যথার্থতা পরীক্ষা করতে চাই যা এটি আগে দেখেনি। মূল প্রশিক্ষণ ডেটার একটি ভগ্নাংশ পৃথক্ সেট করে একটি যাচাইকরণ সেট তৈরি করুন। (কেন এখনই টেস্টিং সেটটি ব্যবহার করবেন না? আমাদের লক্ষ্য হল শুধুমাত্র প্রশিক্ষণের ডেটা ব্যবহার করে আমাদের মডেল তৈরি করা এবং টিউন করা, তারপরে আমাদের নির্ভুলতা মূল্যায়ন করার জন্য একবার পরীক্ষার ডেটা ব্যবহার করুন)।

এই টিউটোরিয়ালে, আমরা প্রাথমিক প্রশিক্ষণের নমুনার প্রায় 10% (25000-এর 10%) প্রশিক্ষণের জন্য লেবেলযুক্ত ডেটা হিসাবে এবং বাকিগুলিকে বৈধতা ডেটা হিসাবে নিয়েছি। যেহেতু প্রাথমিক ট্রেন/পরীক্ষার বিভাজন ছিল 50/50 (প্রতিটি 25000টি নমুনা), এখন আমাদের কাছে কার্যকর ট্রেন/বৈধতা/পরীক্ষা বিভাজন হল 5/45/50।

মনে রাখবেন যে 'ট্রেন_ডেটাসেট' ইতিমধ্যেই ব্যাচ এবং শাফেল করা হয়েছে।

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.7/site-packages/keras/engine/functional.py:559: 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.
  inputs = self._flatten_to_reference_inputs(inputs)
21/21 [==============================] - 22s 889ms/step - loss: 0.6932 - accuracy: 0.5065 - val_loss: 0.6928 - val_accuracy: 0.5004
Epoch 2/10
21/21 [==============================] - 17s 841ms/step - loss: 0.6918 - accuracy: 0.5000 - val_loss: 0.6843 - val_accuracy: 0.4988
Epoch 3/10
21/21 [==============================] - 17s 839ms/step - loss: 0.6677 - accuracy: 0.5069 - val_loss: 0.5976 - val_accuracy: 0.6507
Epoch 4/10
21/21 [==============================] - 17s 836ms/step - loss: 0.5579 - accuracy: 0.6912 - val_loss: 0.4801 - val_accuracy: 0.7974
Epoch 5/10
21/21 [==============================] - 17s 837ms/step - loss: 0.4377 - accuracy: 0.7965 - val_loss: 0.3678 - val_accuracy: 0.8372
Epoch 6/10
21/21 [==============================] - 17s 836ms/step - loss: 0.3526 - accuracy: 0.8408 - val_loss: 0.4261 - val_accuracy: 0.8283
Epoch 7/10
21/21 [==============================] - 17s 835ms/step - loss: 0.4090 - accuracy: 0.8273 - val_loss: 0.3961 - val_accuracy: 0.8346
Epoch 8/10
21/21 [==============================] - 17s 834ms/step - loss: 0.3105 - accuracy: 0.8842 - val_loss: 0.2976 - val_accuracy: 0.8813
Epoch 9/10
21/21 [==============================] - 17s 834ms/step - loss: 0.3335 - accuracy: 0.8673 - val_loss: 0.3373 - val_accuracy: 0.8537
Epoch 10/10
21/21 [==============================] - 17s 837ms/step - loss: 0.3104 - accuracy: 0.8765 - val_loss: 0.2804 - val_accuracy: 0.8902

মডেল মূল্যায়ন

এখন, মডেলটি কীভাবে পারফর্ম করে তা দেখা যাক। দুটি মান ফেরত দেওয়া হবে। ক্ষতি (একটি সংখ্যা যা আমাদের ত্রুটির প্রতিনিধিত্ব করে, নিম্ন মানগুলি ভাল), এবং নির্ভুলতা।

results = model.evaluate(test_dataset, steps=HPARAMS.eval_steps)
print(results)
196/196 [==============================] - 16s 76ms/step - loss: 0.3695 - accuracy: 0.8389
[0.3694916367530823, 0.838919997215271]

সময়ের সাথে সঠিকতা/ক্ষতির একটি গ্রাফ তৈরি করুন

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=tf.keras.losses.BinaryCrossentropy(from_logits=True),
    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.7/site-packages/tensorflow/python/framework/indexed_slices.py:446: UserWarning: Converting sparse IndexedSlices(IndexedSlices(indices=Tensor("gradient_tape/GraphRegularization/graph_loss/Reshape_1:0", shape=(None,), dtype=int32), values=Tensor("gradient_tape/GraphRegularization/graph_loss/Reshape:0", shape=(None, 1), dtype=float32), dense_shape=Tensor("gradient_tape/GraphRegularization/graph_loss/Cast:0", shape=(2,), dtype=int32))) to a dense Tensor of unknown shape. This may consume a large amount of memory.
  "shape. This may consume a large amount of memory." % value)
21/21 [==============================] - 28s 1s/step - loss: 0.6928 - accuracy: 0.5131 - scaled_graph_loss: 4.3840e-05 - val_loss: 0.6923 - val_accuracy: 0.4997
Epoch 2/10
21/21 [==============================] - 19s 939ms/step - loss: 0.6852 - accuracy: 0.5158 - scaled_graph_loss: 0.0021 - val_loss: 0.6818 - val_accuracy: 0.4996
Epoch 3/10
21/21 [==============================] - 19s 939ms/step - loss: 0.6698 - accuracy: 0.5123 - scaled_graph_loss: 0.0021 - val_loss: 0.6534 - val_accuracy: 0.5001
Epoch 4/10
21/21 [==============================] - 20s 959ms/step - loss: 0.6194 - accuracy: 0.6285 - scaled_graph_loss: 0.0284 - val_loss: 0.5297 - val_accuracy: 0.7955
Epoch 5/10
21/21 [==============================] - 19s 937ms/step - loss: 0.5805 - accuracy: 0.7346 - scaled_graph_loss: 0.0545 - val_loss: 0.5601 - val_accuracy: 0.6349
Epoch 6/10
21/21 [==============================] - 19s 934ms/step - loss: 0.5509 - accuracy: 0.7662 - scaled_graph_loss: 0.0654 - val_loss: 0.4899 - val_accuracy: 0.7538
Epoch 7/10
21/21 [==============================] - 19s 937ms/step - loss: 0.5326 - accuracy: 0.7877 - scaled_graph_loss: 0.0701 - val_loss: 0.4395 - val_accuracy: 0.7923
Epoch 8/10
21/21 [==============================] - 20s 940ms/step - loss: 0.5157 - accuracy: 0.8258 - scaled_graph_loss: 0.0811 - val_loss: 0.4585 - val_accuracy: 0.7909
Epoch 9/10
21/21 [==============================] - 19s 937ms/step - loss: 0.5063 - accuracy: 0.8388 - scaled_graph_loss: 0.0868 - val_loss: 0.4272 - val_accuracy: 0.8433
Epoch 10/10
21/21 [==============================] - 19s 934ms/step - loss: 0.5053 - accuracy: 0.8438 - scaled_graph_loss: 0.0858 - val_loss: 0.4485 - val_accuracy: 0.7680

মডেল মূল্যায়ন

graph_reg_results = graph_reg_model.evaluate(test_dataset, steps=HPARAMS.eval_steps)
print(graph_reg_results)
196/196 [==============================] - 16s 76ms/step - loss: 0.4890 - accuracy: 0.7246
[0.4889770448207855, 0.7246000170707703]

সময়ের সাথে সঠিকতা/ক্ষতির একটি গ্রাফ তৈরি করুন

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

এটি লক্ষ্য করা যায় যে তত্ত্বাবধানের অনুপাত কমে যাওয়ার সাথে সাথে মডেলের নির্ভুলতাও হ্রাস পায়। এটি বেস মডেল এবং গ্রাফ-নিয়মিত মডেল উভয়ের জন্যই সত্য, ব্যবহৃত মডেল আর্কিটেকচার নির্বিশেষে। যাইহোক, লক্ষ্য করুন যে গ্রাফ-নিয়মিত মডেল উভয় আর্কিটেকচারের জন্য বেস মডেলের চেয়ে ভাল পারফর্ম করে। বিশেষ করে, দ্বি-LSTM মডেল, যখন তত্ত্বাবধানে অনুপাত 0.01 হয়, গ্রাফ-নিয়মিত মডেল নির্ভুলতা ~ 20% বেস মডেল যে এর চেয়ে বেশি। এটি প্রাথমিকভাবে গ্রাফ-নিয়মিত মডেলের জন্য আধা-তত্ত্বাবধানে শিক্ষার কারণে, যেখানে প্রশিক্ষণের নমুনাগুলি ছাড়াও প্রশিক্ষণের নমুনার মধ্যে কাঠামোগত মিল ব্যবহার করা হয়।

উপসংহার

আমরা নিউরাল স্ট্রাকচার্ড লার্নিং (NSL) ফ্রেমওয়ার্ক ব্যবহার করে গ্রাফ নিয়মিতকরণের ব্যবহার প্রদর্শন করেছি এমনকি যখন ইনপুটে একটি স্পষ্ট গ্রাফ থাকে না। আমরা IMDB মুভি রিভিউগুলির সেন্টিমেন্ট শ্রেণীবিভাগের কাজটি বিবেচনা করেছি যার জন্য আমরা পর্যালোচনা এমবেডিংয়ের উপর ভিত্তি করে একটি সাদৃশ্য গ্রাফ সংশ্লেষিত করেছি। আমরা ব্যবহারকারীদের বিভিন্ন হাইপারপ্যারামিটার, তত্ত্বাবধানের পরিমাণ এবং বিভিন্ন মডেল আর্কিটেকচার ব্যবহার করে আরও পরীক্ষা করার জন্য উৎসাহিত করি।