ডিকোডিং API

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

ওভারভিউ

সাম্প্রতিক অতীতে, অটো-রিগ্রেসিভ মডেলগুলির সাথে ভাষা তৈরিতে প্রচুর গবেষণা হয়েছে। স্বয়ং-পশ্চাদমুখী ভাষা প্রজন্মে, সময় ধাপ কে এ টোকেন এর সম্ভাব্যতা বিতরণের পদক্ষেপ কে-1 পর্যন্ত মডেলের টোকেন-ভবিষ্যৎবাণী উপর নির্ভরশীল। এই মডেলের জন্য, যেমন রশ্মি অনুসন্ধান, লোভী, শীর্ষ-পি, ও শীর্ষ-K যেমন ডিকোডিং কৌশল মডেল সমালোচনা উপাদান এবং মূলত একটি প্রদত্ত সময় পদক্ষেপ কে এ টোকেনটি উত্পন্ন আউটপুট শৈলী / প্রকৃতি প্রভাবিত।

উদাহরণস্বরূপ, রশ্মি অনুসন্ধান প্রতিটি সময় পদে পদে অনুমানের সম্ভবত num_beams পালন এবং শেষ পর্যন্ত অনুমান সামগ্রিক সর্বোচ্চ সম্ভাবনা আছে যে চয়ন করে অনুপস্থিত গোপন উচ্চ সম্ভাবনা টোকেন ঝুঁকি কমিয়ে দেয়। মারে এট আল। (2018) এবং ইয়াং এট অল। (2018) যে মরীচি অনুসন্ধান যান্ত্রিক অনুবাদ কর্ম ভাল কাজ করে প্রদর্শন করুন। উভয় রশ্মি অনুসন্ধান & লোলুপ কৌশল পুনরায় টোকেন উৎপাদিত একটি সম্ভাবনা আছে।

ফ্যান ইত্যাদি। আল (2018) চালু শীর্ষ-কে স্যাম্পলিং, যা কে সম্ভবত টোকেন ফিল্টার করা হয় এবং সম্ভাব্যতা ভর কেবলমাত্র সেই কে টোকেন মধ্যে বিতরণ করা হয়।

আরি হোল্টজম্যান এট। আল (2019) চালু শীর্ষ-পি স্যাম্পলিং, যা ক্রমবর্ধমান সম্ভাবনা যে সম্ভাব্যতা P পর্যন্ত যোগ করে দিয়ে টোকেন ক্ষুদ্রতম সম্ভব সেট থেকে পছন্দ করে। সম্ভাব্যতা ভর তারপর এই সেট মধ্যে পুনরায় বিতরণ করা হয়. এইভাবে, টোকেন সেটের আকার গতিশীলভাবে বৃদ্ধি এবং হ্রাস করতে পারে। শীর্ষ-পি, শীর্ষ-K সাধারণভাবে গল্প প্রজন্মের যেমন কর্ম ব্যবহার করা হয়।

ডিকোডিং API অটো-রিগ্রেসিভ মডেলগুলিতে বিভিন্ন ডিকোডিং কৌশল নিয়ে পরীক্ষা করার জন্য একটি ইন্টারফেস প্রদান করে।

  1. নিম্নলিখিত নমুনা কৌশলগুলি sampling_module.py-তে দেওয়া হয়েছে, যা বেস ডিকোডিং ক্লাস থেকে উত্তরাধিকারসূত্রে পাওয়া যায়:

  2. বিম অনুসন্ধান beam_search.py ​​এ প্রদান করা হয়েছে। github

সেটআপ

pip install -q -U tensorflow-text

pip install -q tf-models-nightly

import numpy as np
import matplotlib.pyplot as plt

import tensorflow as tf

from official import nlp
from official.nlp.modeling.ops import sampling_module
from official.nlp.modeling.ops import beam_search

/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/pkg_resources/__init__.py:119: PkgResourcesDeprecationWarning: 0.18ubuntu0.18.04.1 is an invalid version and will not be supported in a future release
  PkgResourcesDeprecationWarning,

TF-NLP-তে স্যাম্পলিং মডিউল শুরু করুন।

  • symbols_to_logits_fn: এই অবসান ব্যবহারের জন্য logits ভবিষ্যদ্বাণী করা মডেল ডাকতে index+1 ধাপ। এই বন্ধের জন্য ইনপুট এবং আউটপুটগুলি নিম্নরূপ:
Args:
  1] ids : Current decoded sequences. int tensor with shape (batch_size, index + 1 or 1 if padded_decode is True)],
  2] index [scalar] : current decoded step,
  3] cache [nested dictionary of tensors] : Only used for faster decoding to store pre-computed attention hidden states for keys and values. More explanation in the cell below.
Returns:
  1] tensor for next-step logits [batch_size, vocab]
  2] the updated_cache [nested dictionary of tensors].

দ্রুত ডিকোডিংয়ের জন্য ক্যাশে ব্যবহার করা হয়। এখানে একটি হল রেফারেন্স উপরে অবসান জন্য বাস্তবায়ন।

  • length_normalization_fn: দৈর্ঘ্য নিয়মমাফিককরণ পরামিতি ফিরে এই অবসান ব্যবহার করুন।
Args: 
  1] length : scalar for decoded step index.
  2] dtype : data-type of output tensor
Returns:
  1] value of length normalization factor.

  • vocab_size: আউটপুট শব্দভান্ডার আকার।

  • max_decode_length: ডিকোডিং ধাপের মোট সংখ্যার জন্য স্কালে।

  • eos_id: ডিকোড যদি ব্যাচ সমস্ত আউটপুট সঙ্কেতমুক্ত আইডি এই eos_id আছে বন্ধ করে দেব।

  • padded_decode: সত্য এই সেট করেন তাহলে নমনীয় চলমান। যদি এটি সত্য হয় তাহলে টেনসরগুলিকে max_decoding_length-এ প্যাড করা হয়৷

  • top_k যদি এই মান top_k সক্রিয় করা হয়> 1।

  • top_p যদি এই মান> আছে 0 এবং <1.0 top_p সক্রিয় করা হয়

  • sampling_temperature এই softmax আউটপুট পুনরায় অনুমান করার জন্য ব্যবহার করা হয়। তাপমাত্রা উচ্চ সম্ভাবনার টোকেনের দিকে বন্টনকে তির্যক করে এবং লেজ বিতরণে ভরকে কমিয়ে দেয়। মান ইতিবাচক হতে হবে। নিম্ন তাপমাত্রা লোভের সমতুল্য এবং বিতরণকে তীক্ষ্ণ করে তোলে, যখন উচ্চ তাপমাত্রা এটিকে আরও সমতল করে তোলে।

  • enable_greedy: ডিফল্টরূপে, এটি সত্য হয় এবং লোভী পাঠোদ্ধারতা সক্রিয় করা হয়। অন্যান্য কৌশল নিয়ে পরীক্ষা করতে, অনুগ্রহ করে এটিকে False এ সেট করুন।

মডেল হাইপারপ্যারামিটার শুরু করুন

params = {}
params['num_heads'] = 2
params['num_layers'] = 2
params['batch_size'] = 2
params['n_dims'] = 256
params['max_decode_length'] = 4

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

ক্যাশে আরম্ভ করুন।

cache = {
    'layer_%d' % layer: {
        'k': tf.zeros([params['batch_size'], params['max_decode_length'], params['num_heads'], int(params['n_dims']/params['num_heads'])], dtype=tf.float32),
        'v': tf.zeros([params['batch_size'], params['max_decode_length'], params['num_heads'], int(params['n_dims']/params['num_heads'])], dtype=tf.float32)
        } for layer in range(params['num_layers'])
    }
print("cache key shape for layer 1 :", cache['layer_1']['k'].shape)

cache key shape for layer 1 : (2, 4, 2, 128)

প্রয়োজন হলে দৈর্ঘ্য স্বাভাবিককরণের জন্য বন্ধ সংজ্ঞায়িত করুন।

এটি তৈরি করা সিকোয়েন্সের চূড়ান্ত স্কোর স্বাভাবিক করার জন্য ব্যবহৃত হয় এবং এটি ঐচ্ছিক

def length_norm(length, dtype):
  """Return length normalization factor."""
  return tf.pow(((5. + tf.cast(length, dtype)) / 6.), 0.0)

মডেল_এফএন তৈরি করুন

বাস্তবে, এই যেমন প্রকৃত মডেল বাস্তবায়ন দ্বারা প্রতিস্থাপন করা হবে এখানে

Args:
i : Step that is being decoded.
Returns:
  logit probabilities of size [batch_size, 1, vocab_size]

probabilities = tf.constant([[[0.3, 0.4, 0.3], [0.3, 0.3, 0.4],
                              [0.1, 0.1, 0.8], [0.1, 0.1, 0.8]],
                            [[0.2, 0.5, 0.3], [0.2, 0.7, 0.1],
                              [0.1, 0.1, 0.8], [0.1, 0.1, 0.8]]])
def model_fn(i):
  return probabilities[:, i, :]

চিহ্নগুলি_ থেকে_লগিটস_এফএন শুরু করুন

def _symbols_to_logits_fn():
  """Calculates logits of the next tokens."""
  def symbols_to_logits_fn(ids, i, temp_cache):
    del ids
    logits = tf.cast(tf.math.log(model_fn(i)), tf.float32)
    return logits, temp_cache
  return symbols_to_logits_fn

লোভী

: লোলুপ পাঠোদ্ধারতা তার পরবর্তী ID এর মতো সর্বোচ্চ সম্ভাবনা সঙ্গে টোকেন আইডি নির্বাচন \(id_t = argmax_{w}P(id | id_{1:t-1})\) প্রতিটি timestep এ \(t\)। নিম্নলিখিত স্কেচ লোভী ডিকোডিং দেখায়.

greedy_obj = sampling_module.SamplingModule(
    length_normalization_fn=None,
    dtype=tf.float32,
    symbols_to_logits_fn=_symbols_to_logits_fn(),
    vocab_size=3,
    max_decode_length=params['max_decode_length'],
    eos_id=10,
    padded_decode=False)
ids, _ = greedy_obj.generate(
    initial_ids=tf.constant([9, 1]), initial_cache=cache)
print("Greedy Decoded Ids:", ids)

Greedy Decoded Ids: tf.Tensor(
[[9 1 2 2 2]
 [1 1 1 2 2]], shape=(2, 5), dtype=int32)

top_k নমুনা

শীর্ষ-কে স্যাম্পলিং সালে, কে সম্ভবত পরবর্তী টোকেন আইডি ফিল্টার করা হয় এবং সম্ভাব্যতা ভর কেবলমাত্র সেই কে আইডি মধ্যে বিতরণ করা হয়।

top_k_obj = sampling_module.SamplingModule(
    length_normalization_fn=length_norm,
    dtype=tf.float32,
    symbols_to_logits_fn=_symbols_to_logits_fn(),
    vocab_size=3,
    max_decode_length=params['max_decode_length'],
    eos_id=10,
    sample_temperature=tf.constant(1.0),
    top_k=tf.constant(3),
    padded_decode=False,
    enable_greedy=False)
ids, _ = top_k_obj.generate(
    initial_ids=tf.constant([9, 1]), initial_cache=cache)
print("top-k sampled Ids:", ids)

top-k sampled Ids: tf.Tensor(
[[9 1 0 2 2]
 [1 0 1 2 2]], shape=(2, 5), dtype=int32)

top_p স্যাম্পলিং

পরিবর্তে স্যাম্পলিং একমাত্র থেকে সম্ভবত কে টোকেন আইডি, শীর্ষ-পি আইডি ক্ষুদ্রতম সম্ভব সেট যার ক্রমসঞ্চিত সম্ভাব্যতা সম্ভাব্যতা P অতিক্রম করে থেকে তা চয়ন স্যাম্পলিং হবে।

top_p_obj = sampling_module.SamplingModule(
    length_normalization_fn=length_norm,
    dtype=tf.float32,
    symbols_to_logits_fn=_symbols_to_logits_fn(),
    vocab_size=3,
    max_decode_length=params['max_decode_length'],
    eos_id=10,
    sample_temperature=tf.constant(1.0),
    top_p=tf.constant(0.9),
    padded_decode=False,
    enable_greedy=False)
ids, _ = top_p_obj.generate(
    initial_ids=tf.constant([9, 1]), initial_cache=cache)
print("top-p sampled Ids:", ids)

top-p sampled Ids: tf.Tensor(
[[9 1 1 2 2]
 [1 1 1 0 2]], shape=(2, 5), dtype=int32)

মরীচি অনুসন্ধান ডিকোডিং

বীম অনুসন্ধান প্রতিটি সময় ধাপে হাইপোথিসিসের সর্বাধিক সম্ভাব্য num_beams রেখে এবং শেষ পর্যন্ত সামগ্রিক সর্বোচ্চ সম্ভাবনা রয়েছে এমন হাইপোথিসিস বেছে নেওয়ার মাধ্যমে লুকানো উচ্চ সম্ভাবনার টোকেন আইডি হারিয়ে যাওয়ার ঝুঁকি হ্রাস করে।

beam_size = 2
params['batch_size'] = 1
beam_cache = {
    'layer_%d' % layer: {
        'k': tf.zeros([params['batch_size'], params['max_decode_length'], params['num_heads'], params['n_dims']], dtype=tf.float32),
        'v': tf.zeros([params['batch_size'], params['max_decode_length'], params['num_heads'], params['n_dims']], dtype=tf.float32)
        } for layer in range(params['num_layers'])
    }
print("cache key shape for layer 1 :", beam_cache['layer_1']['k'].shape)
ids, _ = beam_search.sequence_beam_search(
    symbols_to_logits_fn=_symbols_to_logits_fn(),
    initial_ids=tf.constant([9], tf.int32),
    initial_cache=beam_cache,
    vocab_size=3,
    beam_size=beam_size,
    alpha=0.6,
    max_decode_length=params['max_decode_length'],
    eos_id=10,
    padded_decode=False,
    dtype=tf.float32)
print("Beam search ids:", ids)

cache key shape for layer 1 : (1, 4, 2, 256)
Beam search ids: tf.Tensor(
[[[9 0 1 2 2]
  [9 1 2 2 2]]], shape=(1, 2, 5), dtype=int32)