এমএল কমিউনিটি দিবস 9 নভেম্বর! TensorFlow, Jax থেকে আপডেটের জন্য আমাদের সাথে যোগ দিন, এবং আরও আরও জানুন

সংশ্লেষিত গ্রাফ ব্যবহার করে সংবেদন শ্রেণিবদ্ধকরণের জন্য গ্রাফকে নিয়মিতকরণ

টেনসরফ্লো.আর.জে দেখুন গিটহাবের উত্স দেখুন

ওভারভিউ

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

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

  1. ইনপুটটিতে প্রতিটি পাঠ্যের নমুনার জন্য এম্বেডিং তৈরি করুন। এই যেমন প্রাক প্রশিক্ষিত মডেলগুলি ব্যবহার করা যেতে পারে word2vec , সুইভেল , বার্ট ইত্যাদি
  2. এই এলবেডিংয়ের উপর ভিত্তি করে একটি গ্রাফ তৈরি করুন যেমন 'এল 2' দূরত্ব, 'কোসাইন' দূরত্ব ইত্যাদির মতো মিলের মেট্রিক ব্যবহার করে গ্রাফের নোডগুলি গ্রাফের নমুনাগুলির সাথে মিলিত হয় এবং নমুনাগুলির জোড়ার মধ্যে মিলের সাথে মিলিত হয়।
  3. উপরের সংশ্লেষিত গ্রাফ এবং নমুনা বৈশিষ্ট্যগুলি থেকে প্রশিক্ষণ ডেটা তৈরি করুন। ফলাফলের প্রশিক্ষণ ডেটাতে মূল নোড বৈশিষ্ট্যগুলি ছাড়াও প্রতিবেশী বৈশিষ্ট্য থাকবে will
  4. কেরাস অনুক্রমিক, কার্যকরী বা সাবক্লাস এপিআই ব্যবহার করে বেস মডেল হিসাবে নিউরাল নেটওয়ার্ক তৈরি করুন।
  5. একটি নতুন গ্রাফ কেরাস মডেল তৈরি করতে এনএসএল কাঠামো দ্বারা সরবরাহ করা গ্রাফরেগুলাইরেশন র‌্যাপার ক্লাসের সাথে বেস মডেলটি মোড়ুন। এই নতুন মডেলটির প্রশিক্ষণের উদ্দেশ্যে নিয়মিতকরণ শব্দ হিসাবে একটি গ্রাফ নিয়মিতকরণ ক্ষতি অন্তর্ভুক্ত করা হবে।
  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.3.0
Eager mode:  True
Hub version:  0.8.0
GPU is NOT AVAILABLE

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

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

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

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

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

নিম্নলিখিত কোডটি আইএমডিবি ডেটাসেট ডাউনলোড করে (বা এটি ইতিমধ্যে ডাউনলোড করা থাকলে ক্যাশেড অনুলিপি ব্যবহার করে):

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 টি প্রায়শই সংঘটিত শব্দ রাখে। ভোকাবুলারিটির আকার পরিচালনা করার জন্য বিরল শব্দগুলি বাতিল করা হয়।

ডেটা অন্বেষণ করুন

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

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

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

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

pretrained_embedding = 'https://hub.tensorflow.google.cn/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

একটি গ্রাফ তৈরি করুন

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

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

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

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

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

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

  1. আইডি : নমুনার নোড আইডি।
  2. শব্দ : শব্দ আইডি সহ একটি int64 তালিকা list
  3. লেবেল : পর্যালোচনার টার্গেট ক্লাসটি সনাক্তকারী একটি সিঙ্গলটন ইনট 64৪।
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

গ্রাফ প্রতিবেশীদের সাথে আগুন প্রশিক্ষণের ডেটা

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

এই টিউটোরিয়ালে, আমরা অপরিবর্তিত প্রান্তগুলি বিবেচনা করি এবং গ্রাফ প্রতিবেশীদের সাথে প্রশিক্ষণের ডেটা বৃদ্ধিতে নমুনা প্রতি সর্বোচ্চ 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)

বেস মডেল

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

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

0 বি 772ada70

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

প্রশিক্ষণ এবং মূল্যায়নের জন্য ব্যবহৃত বিভিন্ন হাইপারপ্রেমেটার এবং ধ্রুবকগুলিকে HParams করতে আমরা HParams একটি উদাহরণ ব্যবহার করব। আমরা নীচে তাদের প্রতিটি সংক্ষিপ্তভাবে বর্ণনা:

  • num_class : 2 টি শ্রেণি রয়েছে - ধনাত্মক এবং negative ণাত্মক

  • সর্বাধিক_সেক_ দৈর্ঘ্য : এই উদাহরণটিতে প্রতিটি মুভি পর্যালোচনা থেকে বিবেচিত শব্দগুলির সর্বাধিক সংখ্যা।

  • ভোকাব_সাইজ : এই উদাহরণটির জন্য বিবেচিত শব্দভাণ্ডারের এটি আকার।

  • দূরত্ব_প্রকার : এটি প্রতিবেশীদের সাথে নমুনাকে নিয়মিত করতে ব্যবহৃত দূরত্বের মেট্রিক।

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

  • num_neighbors : গ্রাফ নিয়মিতকরণের জন্য ব্যবহৃত প্রতিবেশীর সংখ্যা। এই মান এর চেয়ে বড় বা কম সমান হতে হয়েছে max_nbrs যখন invoking উপরে ব্যবহৃত যুক্তিnsl.tools.pack_nbrs

  • num_fc_units : নিউরাল নেটওয়ার্কের সম্পূর্ণ সংযুক্ত স্তরে ইউনিটের সংখ্যা।

  • ট্রেন_পোচস : প্রশিক্ষণ পর্বের সংখ্যা।

  • ব্যাচ_সাইজ : প্রশিক্ষণ এবং মূল্যায়নের জন্য ব্যাচের আকার ব্যবহৃত হয়।

  • eval_steps : মূল্যায়ন মূল্যায়ন সম্পূর্ণ হওয়ার আগে ব্যাচের সংখ্যা প্রক্রিয়া করতে হবে। যদি সেট করা 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()

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

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

  • এক-হট এনকোডিংয়ের অনুরূপ শব্দের উপস্থিতি নির্দেশ করে 0 টি আর 1 এর ভেক্টরে অ্যারেগুলিকে রূপান্তর করুন। উদাহরণস্বরূপ, সিকোয়েন্স [3, 5] একটি 10000 মাত্রিক ভেক্টর হয়ে উঠবে যা সূচক 3 এবং 5 বাদে সমস্ত শূন্য, যা একই are তারপরে, এটি আমাদের নেটওয়ার্কের প্রথম স্তর করুন - একটি Dense স্তর — যা ভাসমান পয়েন্ট ভেক্টর ডেটা পরিচালনা করতে পারে। এই পদ্ধতির একটি মেমরি নিবিড়, যদিও, একটি num_words * num_reviews আকার ম্যাট্রিক্স প্রয়োজন।

  • বিকল্পভাবে, আমরা অ্যারেগুলিকে প্যাড করতে পারি যাতে সেগুলির দৈর্ঘ্য একই থাকে, তারপরে আকারের max_length * num_reviews এর একটি পূর্ণসংখ্যা টেনসর তৈরি করুন। আমরা আমাদের নেটওয়ার্কের প্রথম স্তর হিসাবে এই আকারটি পরিচালনা করতে সক্ষম একটি এম্বেডিং স্তর ব্যবহার করতে পারি।

এই টিউটোরিয়ালে, আমরা দ্বিতীয় পদ্ধতির ব্যবহার করব।

যেহেতু সিনেমার পর্যালোচনাগুলি একই দৈর্ঘ্য হওয়া উচিত, আমরা pad_sequence করার জন্য নীচে সংজ্ঞায়িত 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 হয়।

আমরা এই টিউটোরিয়ালে আমাদের বেস মডেল হিসাবে দ্বি-নির্দেশমূলক এলএসটিএম ব্যবহার করব।

# 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) : (batch, sequence, embedding)
  3. এরপরে, দ্বি দ্বি নির্দেশমূলক এলএসটিএম স্তর প্রতিটি উদাহরণের জন্য একটি নির্দিষ্ট দৈর্ঘ্যের আউটপুট ভেক্টর প্রদান করে।
  4. এই স্থির দৈর্ঘ্যের আউটপুট ভেক্টরটি 64 টি গোপন ইউনিটগুলির সাথে সম্পূর্ণ-সংযুক্ত ( Dense ) স্তরটির মাধ্যমে পাইপ করা হয়।
  5. শেষ স্তরটি একক আউটপুট নোডের সাথে ঘনভাবে সংযুক্ত। sigmoid অ্যাক্টিভেশন ফাংশনটি ব্যবহার করে এই মানটি 0 এবং 1 এর মধ্যে একটি ভাসমান, যা সম্ভাবনা বা আত্মবিশ্বাসের স্তরকে উপস্থাপন করে।

লুকানো ইউনিট

উপরের মডেলটিতে ইনপুট এবং আউটপুট এবং Embedding স্তরটি বাদ দিয়ে দুটি মাঝারি বা "লুকানো" স্তর রয়েছে। আউটপুট সংখ্যা (ইউনিট, নোড, বা নিউরন) স্তর জন্য প্রতিনিধিত্বমূলক স্থানের মাত্রা। অন্য কথায়, অভ্যন্তরীণ উপস্থাপনা শেখার সময় নেটওয়ার্কের যে পরিমাণ স্বাধীনতা অনুমোদিত।

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

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

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

model.compile(
    optimizer='adam', loss='binary_crossentropy', 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.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 917ms/step - loss: 0.6930 - accuracy: 0.5081 - val_loss: 0.6924 - val_accuracy: 0.5518
Epoch 2/10
21/21 [==============================] - 18s 878ms/step - loss: 0.6902 - accuracy: 0.5319 - val_loss: 0.6587 - val_accuracy: 0.6465
Epoch 3/10
21/21 [==============================] - 18s 879ms/step - loss: 0.6338 - accuracy: 0.6731 - val_loss: 0.5882 - val_accuracy: 0.7310
Epoch 4/10
21/21 [==============================] - 18s 872ms/step - loss: 0.4889 - accuracy: 0.7854 - val_loss: 0.4445 - val_accuracy: 0.8047
Epoch 5/10
21/21 [==============================] - 18s 872ms/step - loss: 0.3911 - accuracy: 0.8369 - val_loss: 0.3870 - val_accuracy: 0.8352
Epoch 6/10
21/21 [==============================] - 18s 877ms/step - loss: 0.3544 - accuracy: 0.8542 - val_loss: 0.3420 - val_accuracy: 0.8571
Epoch 7/10
21/21 [==============================] - 19s 900ms/step - loss: 0.3262 - accuracy: 0.8700 - val_loss: 0.3135 - val_accuracy: 0.8762
Epoch 8/10
21/21 [==============================] - 18s 871ms/step - loss: 0.2770 - accuracy: 0.8977 - val_loss: 0.2739 - val_accuracy: 0.8923
Epoch 9/10
21/21 [==============================] - 18s 872ms/step - loss: 0.2863 - accuracy: 0.8958 - val_loss: 0.2703 - val_accuracy: 0.8942
Epoch 10/10
21/21 [==============================] - 18s 875ms/step - loss: 0.2232 - accuracy: 0.9150 - val_loss: 0.2543 - val_accuracy: 0.9037

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

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

results = model.evaluate(test_dataset, steps=HPARAMS.eval_steps)
print(results)
196/196 [==============================] - 16s 82ms/step - loss: 0.3748 - accuracy: 0.8500
[0.37483155727386475, 0.8500000238418579]

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

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

পিএনজি

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

পিএনজি

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

গ্রাফ নিয়মিতকরণ

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

গ্রাফ-নিয়মিত মডেল তৈরি করুন

গ্রাফ নিয়মিতকরণের বর্ধিত সুবিধার মূল্যায়ন করতে, আমরা একটি নতুন বেস মডেল উদাহরণ তৈরি করব। এ কারণে যে 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.6925 - accuracy: 0.5135 - scaled_graph_loss: 7.8682e-06 - val_loss: 0.6925 - val_accuracy: 0.5207
Epoch 2/10
21/21 [==============================] - 22s 1s/step - loss: 0.6902 - accuracy: 0.5373 - scaled_graph_loss: 2.3502e-05 - val_loss: 0.6591 - val_accuracy: 0.6627
Epoch 3/10
21/21 [==============================] - 21s 981ms/step - loss: 0.6376 - accuracy: 0.6942 - scaled_graph_loss: 0.0028 - val_loss: 0.6867 - val_accuracy: 0.5343
Epoch 4/10
21/21 [==============================] - 20s 975ms/step - loss: 0.6240 - accuracy: 0.7031 - scaled_graph_loss: 9.6606e-04 - val_loss: 0.5891 - val_accuracy: 0.7572
Epoch 5/10
21/21 [==============================] - 20s 973ms/step - loss: 0.5111 - accuracy: 0.7896 - scaled_graph_loss: 0.0059 - val_loss: 0.4260 - val_accuracy: 0.8207
Epoch 6/10
21/21 [==============================] - 21s 981ms/step - loss: 0.3816 - accuracy: 0.8508 - scaled_graph_loss: 0.0157 - val_loss: 0.3182 - val_accuracy: 0.8682
Epoch 7/10
21/21 [==============================] - 20s 976ms/step - loss: 0.3488 - accuracy: 0.8704 - scaled_graph_loss: 0.0202 - val_loss: 0.3156 - val_accuracy: 0.8749
Epoch 8/10
21/21 [==============================] - 20s 973ms/step - loss: 0.3227 - accuracy: 0.8815 - scaled_graph_loss: 0.0198 - val_loss: 0.2746 - val_accuracy: 0.8932
Epoch 9/10
21/21 [==============================] - 21s 1s/step - loss: 0.3058 - accuracy: 0.8958 - scaled_graph_loss: 0.0220 - val_loss: 0.2938 - val_accuracy: 0.8833
Epoch 10/10
21/21 [==============================] - 21s 979ms/step - loss: 0.2789 - accuracy: 0.9008 - scaled_graph_loss: 0.0233 - val_loss: 0.2622 - val_accuracy: 0.8981

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

graph_reg_results = graph_reg_model.evaluate(test_dataset, steps=HPARAMS.eval_steps)
print(graph_reg_results)
196/196 [==============================] - 16s 82ms/step - loss: 0.3543 - accuracy: 0.8508
[0.354336142539978, 0.8507599830627441]

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

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

পিএনজি

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

পিএনজি

আধা তত্ত্বাবধানে শিক্ষার শক্তি

অর্ধ-তত্ত্বাবধানে পড়াশোনা এবং আরও বিশেষত, এই টিউটোরিয়ালটির প্রসঙ্গে গ্রাফ নিয়মিতকরণ, যখন প্রশিক্ষণের ডেটার পরিমাণ কম হয় তখন সত্যই শক্তিশালী হতে পারে। প্রশিক্ষণের নমুনাগুলির মধ্যে সাদৃশ্য অর্জনের মাধ্যমে প্রশিক্ষণের তথ্যের অভাবকে ক্ষতিপূরণ দেওয়া হয় যা traditionalতিহ্যবাহী তদারকি করা শেখায় সম্ভব নয়।

আমরা প্রশিক্ষণের নমুনার অনুপাত হিসাবে তদারকির অনুপাতটিকে সংখ্যার সাথে সংখ্যার সংখ্যার হিসাবে সংজ্ঞায়িত করি যার মধ্যে প্রশিক্ষণ, বৈধতা এবং পরীক্ষার নমুনা রয়েছে। এই নোটবুকে, আমরা বেস মডেল পাশাপাশি গ্রাফ-নিয়মিত মডেল উভয়কে প্রশিক্ষণের জন্য 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>

পিএনজি

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

উপসংহার

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