डिकोडिंग एपीआई

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

अवलोकन

हाल के दिनों में, ऑटो-रिग्रेसिव मॉडल के साथ भाषा निर्माण में बहुत सारे शोध हुए हैं। ऑटो प्रतिगामी भाषा पीढ़ी में, समय कदम कश्मीर पर टोकन के प्रायिकता वितरण कदम के -1 तक मॉडल की टोकन-भविष्यवाणियों पर निर्भर है। इन मॉडलों के लिए, ऐसे बीम खोज, लालची, टॉप-पी, और टॉप-कश्मीर के रूप में डिकोडिंग रणनीतियों मॉडल के महत्वपूर्ण घटक हैं और काफी हद तक एक निश्चित समय कदम कश्मीर पर टोकन उत्पन्न उत्पादन की शैली / प्रकृति प्रभावित करते हैं।

उदाहरण के लिए, बीम खोज हर बार कदम पर परिकल्पना की सबसे अधिक संभावना num_beams रखने और अंत में परिकल्पना समग्र उच्चतम संभावना है कि चयन करके लापता छिपा उच्च संभावना टोकन के खतरे को कम। मरे एट अल। (2018) और यांग एट अल। (2018) है कि किरण खोज मशीन अनुवाद कार्य में अच्छी तरह से काम करता है दिखाते हैं। दोनों बीम खोज और लालची रणनीति को दोहरा टोकन पैदा करने की संभावना है।

पंखा वगैरह। अल (2018) की शुरुआत की टॉप-कश्मीर नमूना है, जिसमें कश्मीर सबसे अधिक संभावना टोकन फ़िल्टर्ड रहे हैं और संभावना बड़े पैमाने पर केवल उन्हीं कश्मीर टोकन के बीच पुनः वितरित किया जाता है।

अरी होल्ट्ज़मैन एट। अल (2019) की शुरुआत की टॉप-पी नमूना है, जो संचयी संभावना है कि संभावना पी तक कहते हैं के साथ टोकन की छोटी संभव सेट से चुनता है। संभाव्यता द्रव्यमान को फिर इस सेट के बीच पुनर्वितरित किया जाता है। इस तरह, टोकन के सेट का आकार गतिशील रूप से बढ़ और घट सकता है। टॉप-पी, शीर्ष-कश्मीर आम तौर पर ऐसे कहानी पीढ़ी के रूप में कार्य किया जाता है।

डिकोडिंग एपीआई ऑटो-प्रतिगामी मॉडल पर विभिन्न डिकोडिंग रणनीतियों के साथ प्रयोग करने के लिए एक इंटरफ़ेस प्रदान करता है।

  1. निम्नलिखित नमूनाकरण रणनीतियाँ sample_module.py में प्रदान की जाती हैं, जो मूल डिकोडिंग वर्ग से विरासत में मिलती हैं:

  2. बीम खोज बीम_सर्च.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: सही पर सेट करें यदि TPU पर चल रहा है। यदि यह सत्य है तो टेंसर को max_decoding_length पर गद्देदार किया जाता है।

  • top_k: अगर यह मूल्य है top_k सक्षम किया गया है> 1।

  • top_p: अगर यह मान> है 0 और <1.0 top_p सक्षम किया गया है

  • sampling_temperature: यह softmax उत्पादन फिर से आकलन करने के लिए प्रयोग किया जाता है। तापमान वितरण को उच्च संभावना वाले टोकन की ओर ले जाता है और पूंछ वितरण में द्रव्यमान को कम करता है। मान सकारात्मक होना चाहिए। कम तापमान लालची के बराबर होता है और वितरण को तेज बनाता है, जबकि उच्च तापमान इसे और अधिक सपाट बनाता है।

  • enable_greedy: डिफ़ॉल्ट रूप से, यह सच है और लालची डिकोडिंग सक्षम है। अन्य रणनीतियों के साथ प्रयोग करने के लिए, कृपया इसे गलत पर सेट करें।

मॉडल हाइपरपैरामीटर को इनिशियलाइज़ करें

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)

मॉडल_fn . बनाएं

व्यवहार में, इस तरह के रूप में एक वास्तविक मॉडल कार्यान्वयन से बदल दिया जाएगा यहाँ

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, :]

इनिशियलाइज़ सिंबल_to_logits_fn

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_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_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 नमूनाकरण

इसके बजाय नमूने का केवल से सबसे अधिक संभावना कश्मीर टोकन आईडी, टॉप-पी आईडी की छोटी संभव सेट जिसका संचयी संभावना संभावना पी से अधिक से चुनें नमूने में।

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)

बीम खोज डिकोडिंग

बीम खोज हर समय कदम पर परिकल्पना की सबसे संभावित संख्या_बीम रखने और अंततः उस परिकल्पना का चयन करके छिपी हुई उच्च संभावना टोकन आईडी के लापता होने के जोखिम को कम करती है जिसकी समग्र उच्चतम संभावना है।

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)