Kod çözme API'si

TensorFlow.org'da görüntüleyin Google Colab'da çalıştırın GitHub'da görüntüle Not defterini indir

genel bakış

Yakın geçmişte, otoregresif modellerle dil üretimi konusunda çok sayıda araştırma yapılmıştır. Kendiliğinden gerileyen dil nesilde zaman adımı K belirteç olasılık dağılımı adımı K-1 kadar modelin belirteci tahminlerin bağlıdır. Bu modellerin bu Işın arama, Açgözlü, Yukarıdan p ve Üst k olarak deşifre stratejileri modelin kritik bileşenleridir ve büyük ölçüde belirli bir zaman adımı K'de belirteci üretilen çıktının stil / doğasını etkiler.

Örneğin, Işın arama her zaman adımında hipotezlerin büyük olasılıkla num_beams tutmak ve sonunda genel olasılığının çok yüksek olduğu hipotezini seçerek eksik gizli yüksek olasılık jeton riskini azaltır. Murray et al. (2018) ve Yang ve diğ. (2018) bu ışın arama Makine Çevirisi görevleri iyi çalışır göstermektedir. Işın arama ve Açgözlü stratejileri Hem tekrar belirteçleri üreten bir imkanı vardır.

Fan et. (2018) ve arkadaşları, büyük olasılıkla belirteçleri filtrelenir K ve olasılık sadece bu K belirteçleri arasında dağıtılır ki burada en-K örnekleme, kişiye.

Ari Holtzman et. (2019) ve arkadaşları, p olasılıkla kadar ekler toplam olasılık ile jeton mümkün olan en küçük kümesinden seçer en-p örnekleme, kişiye. Olasılık kütlesi daha sonra bu küme arasında yeniden dağıtılır. Bu şekilde, jeton kümesinin boyutu dinamik olarak artabilir ve azalabilir. Üst p, Yukarıdan k genellikle hikaye nesil gibi görevler kullanılmaktadır.

Kod Çözme API'si, otomatik gerilemeli modellerde farklı kod çözme stratejilerini denemek için bir arabirim sağlar.

  1. Temel Kod Çözme sınıfından miras alınan örnekleme_module.py dosyasında aşağıdaki örnekleme stratejileri sağlanır:

  2. Işın araması, beam_search.py'de sağlanır. github

Kurmak

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'de Örnekleme Modülünü başlatın.

  • symbols_to_logits_fn: Yalnızca bu kapatma için logits tahmin etmek modelini aramaya index+1 adım. Bu kapatma için girişler ve çıkışlar aşağıdaki gibidir:
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].

Önbellek daha hızlı kod çözme için kullanılır. İşte olan referans yukarıdaki kapatılması için uygulanması.

  • length_normalization_fn: Kullanım uzunluğu normalleşme parametresini döndürmek için bu kapatma.
Args: 
  1] length : scalar for decoded step index.
  2] dtype : data-type of output tensor
Returns:
  1] value of length normalization factor.

  • vocab_size: Çıktı kelime boyutu.

  • max_decode_length: Skaler deşifre adımların toplam sayısı için.

  • eos_id: toplu tüm çıkış deşifre kimlikleri bu eos_id varsa Kod Çözme duracaktır.

  • padded_decode: TPU üzerinde çalışan eğer true bu ayarlayın. Bu True ise, tensörler max_decoding_length ile doldurulur.

  • top_k: bu değer ise top_k> 1 etkindir.

  • top_p: Bu değer> 0 ve <1.0 ise top_p etkindir

  • sampling_temperature Bu yeniden tahmin SoftMax çıkış için kullanılır. Sıcaklık, dağılımı yüksek olasılık belirteçlerine doğru çarpıtır ve kuyruk dağılımındaki kütleyi düşürür. Değer pozitif olmalıdır. Düşük sıcaklık açgözlülüğe eşdeğerdir ve dağılımı daha keskin hale getirirken, yüksek sıcaklık onu daha düz hale getirir.

  • enable_greedy: Varsayılan olarak, bu gerçek ve açgözlü kod çözme etkindir. Diğer stratejileri denemek için lütfen bunu False olarak ayarlayın.

Model hiper parametrelerini başlat

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

Trafo merkezli gibi kendiliğinden gerileyen mimarileri de Encoder-Decoder modelleri, Önbellek hızlı sıralı şifre çözümü için kullanılır. Her katman için önceden hesaplanmış gizli durumları (öz-dikkat bloklarındaki ve çapraz dikkat bloklarındaki anahtar ve değerler) depolayan iç içe bir sözlüktür.

Önbelleği başlat.

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)

Gerekirse uzunluk normalizasyonu için kapatmayı tanımlayın.

Bu, oluşturulan dizilerin son puanlarını normalleştirmek için kullanılır ve isteğe bağlıdır.

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

model_fn oluştur

Uygulamada bu gibi gerçek bir modeli uygulaması ile değiştirilecektir burada

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

Symbols_to_logits_fn'yi başlat

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

Aç gözlü

: Açgözlü çözme en yüksek bir sonraki kimliğiyle olasılığıyla belirteç kimliği seçer \(id_t = argmax_{w}P(id | id_{1:t-1})\) her timestep de \(t\). Aşağıdaki çizim açgözlü kod çözmeyi göstermektedir.

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 örnekleme

Üst-K örneklemede, K büyük olasılıkla bir sonraki belirteç kimlikleri filtrelenir ve olasılık sadece bu K kimlikleri arasında yeniden dağıtılır.

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 örnekleme

Bunun yerine örnekleme sadece büyük olasılıkla K belirteç kimlikleri, kümülatif olasılık olasılık p aştığı kimlikleri mümkün olan en küçük kümesinden kendi istediğim örnekleme Üst 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)

Işın arama kod çözme

Işın araması, her bir zaman adımında en olası hipotez sayılarını koruyarak ve nihayetinde genel olarak en yüksek olasılığa sahip hipotezi seçerek, gizli yüksek olasılık belirteç kimliklerini kaçırma riskini azaltır.

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)