# Sabit uzunluklu modellerin perplexity değeri

Perplexity (PPL), dil modellerini değerlendirmek için kullanılan en yaygın metriklerden biridir. Konuya derinlemesine girmeden önce, bu metriğin özellikle klasik dil modellerine (bazen otoregresif veya nedensel dil modelleri olarak adlandırılır) uygulandığını ve BERT gibi maskeli dil modelleri için iyi tanımlanmadığını belirtmek gerekir.

Perplexity, bir dizinin üstel ortalama negatif log-olasılıklığı olarak tanımlanır. $X = (x_0, x_1, \dots, x_t)$ şeklinde tokenize edilmiş bir dizimiz varsa, $X$'in perplexity'si,

$$ \text{PPL}(X) = \exp\left\{ -\frac{1}{t}\sum_i^t \log p_\theta (x_i|x_{<i})  \right\} $$

burada $\log p_\theta (x_i|x_{<i})$, modelimize göre önceki tokenlar $x_{<i})$ koşuluna bağlı olarak i. token'ın log-olabilirliğidir. Sezgisel olarak, bir korpus içinde belirtilen token kümesi arasında eşit dağılımla tahmin yapma yeteneğinin bir değerlendirmesi olarak düşünülebilir. Önemli olan, bu durumun tokenizasyon sürecinin bir modelin perplexity'si üzerinde doğrudan bir etkisi olduğu ve farklı modeller karşılaştırılırken bunun her zaman göz önünde bulundurulması gerektiği anlamına gelmesidir.

Bu, veriler ile model tahminleri arasındaki çapraz entropinin üslenmesine de eşdeğerdir. Perplexity (şaşkınlık) hakkında daha fazla sezgi ve bunun Karakter Başına Bit (BPC) ile veri sıkıştırması arasındaki ilişki için, The Gradient'teki bu [mükemmel blog yazısına](https://thegradient.pub/understanding-evaluation-metrics-for-language-models/) göz atın.

## Sabit uzunluklu modellerle PPL hesaplama

Bir modelin bağlam boyutuyla sınırlı olmasaydık, modelin perplexity değerini, aşağıda gösterildiği gibi, bir diziyi otoregresif olarak faktörize ederek ve her adımda tüm önceki alt diziye koşullandırarak değerlendirirdik.

Ancak yaklaşık modellerle çalışırken, modelin işleyebileceği token sayısı üzerinde genellikle bir kısıtlama bulunur. Örneğin, [GPT-2](model_doc/gpt2)'nin en büyük sürümü 1024 token'lık sabit bir uzunluğa sahiptir; bu nedenle $t$ 1024'ten büyük olduğunda $p_\theta(x_t|x_{<t})$ değerini doğrudan hesaplayamayız.

Bunun yerine, dizi genellikle modelin maksimum giriş boyutuna eşit alt dizilere bölünür. Bir modelin maksimum giriş boyutu $k$ ise, bir $x_t$ token'ının olasılığını, tüm bağlam yerine yalnızca onu takip eden $k-1$ token'a koşullandırarak yaklaşık olarak hesaplarız. Bir dizinin model karmaşıklığını (perplexity) değerlendirirken, çekici ama suboptimal bir yaklaşım, diziyi ayrık parçalara bölmek ve her segmentin ayrıştırılmış log-olasılıklarını bağımsız olarak toplamaktır.

Bu, her segmentin sürpriz değerinin (perplexity) tek bir ileri geçişte hesaplanabilmesi nedeniyle hızlı bir şekilde hesaplanır; ancak tamamen ayrıştırılmış sürpriz değerinin (perplexity) zayıf bir yaklaşımıdır ve modelin tahmin adımlarının çoğunda daha az bağlama sahip olacağı için genellikle daha yüksek (daha kötü) bir PPL değeri verir.

Bunun yerine, sabit uzunluklu modellerin PPL değeri, kayan pencere stratejisiyle değerlendirilmelidir. Bu, modelin her tahmini yaparken daha fazla bağlama sahip olması için bağlam penceresinin tekrar tekrar kaydırılmasını içerir.

Bu, dizgi olasılığının gerçek ayrışımına daha yakın bir yaklaşımdır ve genellikle daha elverişli bir puan verir. Dezavantajı, korpusdaki her token için ayrı bir ileri geçiş gerektirmesidir. İyi bir pratik uzlaşma, bağlamı her seferinde 1 token kaydırmak yerine daha büyük adımlarla ilerleterek aralıklı bir kayan pencere kullanmaktır. Bu, modelin her adımda tahmin yapması için büyük bir bağlam sunarken hesaplamaların çok daha hızlı ilerlemesine olanak tanır.

## Örnek: 🤗 Transformers ile GPT-2 kullanılarak perplexity hesaplama

Bu süreci GPT-2 ile gösterelim.

```python
from transformers import GPT2LMHeadModel, GPT2TokenizerFast
from accelerate import Accelerator

device = Accelerator().device
model_id = "openai-community/gpt2-large"
model = GPT2LMHeadModel.from_pretrained(model_id).to(device)
tokenizer = GPT2TokenizerFast.from_pretrained(model_id)
```

WikiText-2 veri setini yükleyip karmaşıklığı (perplexity) birkaç farklı kayan pencere (sliding-window) stratejisiyle değerlendireceğiz. Bu veri seti küçük olduğu ve veri seti üzerinde yalnızca bir ileri geçiş (forward pass) yapacağımız için, tüm veri setini belleğe yükleyip kodlayabiliriz.

```python
from datasets import load_dataset

test = load_dataset("Salesforce/wikitext", "wikitext-2-raw-v1", split="test")
encodings = tokenizer("\n\n".join(test["text"]), return_tensors="pt")
```

🤗 Transformers ile `input_ids` değerlerini modelimize doğrudan `labels` olarak iletebiliriz; bu durumda her token için ortalama negatif log-olabilirlik, kayıp olarak döndürülür. Ancak kayan pencere yaklaşımımızda, her yinelemede modele ilettiğimiz tokenlar arasında örtüşme vardır. Sadece bağlam olarak ele aldığımız tokenların log-olabilirliklerinin kayıp hesabına dahil edilmesini istemiyoruz; bu nedenle bu hedefleri `-100` olarak ayarlayarak yok sayılmasını sağlayabiliriz. Aşağıda, `512` adım (stride) ile bunu nasıl yapabileceğimize dair bir örnek yer almaktadır. Bu, herhangi bir tokenın koşullu olabilirliğini hesapladığında modelin bağlam olarak en az 512 tokene sahip olacağı anlamına gelir (koşullanmak için 512 önceki tokenın mevcut olması koşuluyla).

```python
import torch
from tqdm import tqdm

max_length = model.config.n_positions
stride = 512
seq_len = encodings.input_ids.size(1)

nll_sum = 0.0
n_tokens = 0
prev_end_loc = 0
for begin_loc in tqdm(range(0, seq_len, stride)):
    end_loc = min(begin_loc + max_length, seq_len)
    trg_len = end_loc - prev_end_loc  # may be different from stride on last loop
    input_ids = encodings.input_ids[:, begin_loc:end_loc].to(device)
    target_ids = input_ids.clone()
    target_ids[:, :-trg_len] = -100

    with torch.no_grad():
        outputs = model(input_ids, labels=target_ids)

        # loss is calculated using CrossEntropyLoss which averages over valid labels
        # N.B. the model only calculates loss over trg_len - 1 labels, because it internally shifts the labels
        # to the left by 1.
        neg_log_likelihood = outputs.loss

    # Accumulate the total negative log-likelihood and the total number of tokens
    num_valid_tokens = (target_ids != -100).sum().item()  # number of valid tokens in target_ids
    batch_size = target_ids.size(0)
    num_loss_tokens = num_valid_tokens - batch_size  # subtract batch_size due to internal label shift
    nll_sum += neg_log_likelihood * num_loss_tokens
    n_tokens += num_loss_tokens

    prev_end_loc = end_loc
    if end_loc == seq_len:
        break

avg_nll = nll_sum / n_tokens  # average negative log-likelihood per token
ppl = torch.exp(avg_nll)
```

Bu işlemi, adım uzunluğu maksimum giriş uzunluğuna eşit olacak şekilde çalıştırmak, yukarıda tartıştığımız alt optimum, kayan pencere olmayan stratejiye eşdeğerdir. Adım ne kadar küçükse, modelin her tahmini yaparken sahip olacağı bağlam o kadar fazla olur ve raporlanan perplexity değeri genellikle o kadar iyi olur.

Yukarıdaki kodu `stride = 1024` ile, yani herhangi bir örtüşme olmadan çalıştırdığımızda, elde edilen PPL değeri `19.44` olur; bu, GPT-2 makalesinde raporlanan `19.93` değerine yakındır. `stride = 512` kullanarak ve böylece kayan pencere stratejimizi devreye alarak bu değer `16.44` seviyesine düşer. Bu, yalnızca daha elverişli bir skor olmakla kalmaz, aynı zamanda bir dizinin olasılığının gerçek otoregresif ayrışmasına daha yakın bir şekilde hesaplanır.

