Menggunakan LIT untuk Menganalisis Model Gemma di Keras

Lihat tentang AI Generatif Menjalankan di Google Colab Lihat sumber di GitHub Pelajari di Codelab

Pengantar

Produk AI generatif relatif baru dan perilaku aplikasi dapat lebih bervariasi daripada bentuk software sebelumnya. Oleh karena itu, penting untuk menyelidiki model machine learning yang digunakan, memeriksa contoh perilaku model, dan menyelidiki hal-hal yang tidak terduga.

Alat Penafsiran Pembelajaran (LIT; situs, GitHub) adalah platform untuk men-debug dan menganalisis model ML guna memahami alasan dan cara perilakunya.

Dalam codelab ini, Anda akan mempelajari cara menggunakan LIT untuk mendapatkan lebih banyak manfaat dari model Gemma Google. Codelab ini menunjukkan cara menggunakan sequence salience, yakni teknik penafsiran, untuk menganalisis berbagai pendekatan engineering prompt.

Tujuan pembelajaran:

  1. Memahami {i>Sequence salience<i} dan penggunaannya dalam analisis model.
  2. Menyiapkan LIT untuk Gemma guna menghitung output prompt dan salience urutan.
  3. Menggunakan salience urutan melalui modul LM Salience untuk memahami dampak desain prompt pada output model.
  4. Pengujian membuat hipotesis peningkatan perintah di LIT dan melihat dampaknya.

Catatan: codelab ini menggunakan implementasi KerasNLP Gemma, dan TensorFlow v2 untuk backend. Sebaiknya gunakan kernel GPU untuk mengikutinya.

Pentingnya Urutan dan Penggunaannya dalam Analisis Model

Model generatif teks ke teks, seperti Gemma, mengambil urutan input dalam bentuk teks yang ditokenkan dan menghasilkan token baru yang merupakan tindak lanjut atau penyelesaian umum terhadap input tersebut. Pembuatan token ini terjadi satu per satu, dengan menambahkan (dalam satu loop) setiap token yang baru dihasilkan ke input ditambah generasi sebelumnya hingga model mencapai kondisi penghentian. Contohnya mencakup saat model menghasilkan token end-of-sequence (EOS) atau mencapai panjang maksimum yang telah ditentukan.

Metode Salience adalah class teknik AI yang dapat dijelaskan (XAI) yang dapat memberi tahu Anda bagian input mana yang penting bagi model untuk berbagai bagian dari outputnya. LIT mendukung metode salience untuk berbagai tugas klasifikasi, yang menjelaskan dampak serangkaian token input pada label yang diprediksi. Sequence salience menggeneralisasi metode ini menjadi model generatif teks ke teks dan menjelaskan dampak token sebelumnya pada token yang dihasilkan.

Di sini, Anda akan menggunakan metode Grad L2 Norm untuk membuat arti urutan, yang menganalisis gradien model dan memberikan besarnya pengaruh dari setiap token sebelumnya terhadap output. Metode ini sederhana dan efisien, serta telah menunjukkan performa yang baik dalam klasifikasi dan setelan lainnya. Semakin besar skor {i>salience<i}, semakin tinggi pengaruhnya. Metode ini digunakan dalam LIT karena telah dipahami dengan baik dan digunakan secara luas di seluruh komunitas penelitian penafsiran.

Metode salience berbasis gradien yang lebih canggih mencakup Grad ⋅ Input dan gradien terintegrasi. Ada juga metode berbasis ablasi yang tersedia, seperti LIME dan SHAP, yang dapat lebih andal tetapi jauh lebih mahal untuk dihitung. Lihat artikel ini untuk mengetahui perbandingan mendetail tentang berbagai metode keterlihatan.

Anda dapat mempelajari sains metode salience lebih lanjut dalam eksplorasi interaktif pengantar yang dapat dieksplorasi ini.

Impor, Lingkungan, dan Kode Penyiapan Lainnya

ERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.
bigframes 0.21.0 requires scikit-learn>=1.2.2, but you have scikit-learn 1.0.2 which is incompatible.
google-colab 1.0.0 requires ipython==7.34.0, but you have ipython 8.14.0 which is incompatible.

Hal ini aman untuk diabaikan.

Menginstal LIT dan Keras NLP

Untuk codelab ini, Anda memerlukan versi terbaru keras (3) keras-nlp (0.8.0) dan lit-nlp (1.1), serta akun Kaggle untuk mendownload model dasar.

pip install -q -U lit-nlp
pip uninstall -y umap-learn
pip install -q -U keras-nlp
pip install -q -U keras

Akses Kaggle

Untuk login ke Kaggle, Anda dapat menyimpan file kredensial kaggle.json di ~/.kaggle/kaggle.json atau menjalankan perintah berikut di lingkungan Colab. Lihat dokumentasi paket kagglehub untuk detail selengkapnya.

import kagglehub

kagglehub.login()

Pastikan Anda juga menyetujui perjanjian lisensi untuk Gemma.

Menyiapkan LIT untuk Gemma

Menyiapkan Model LIT

import os

os.environ["KERAS_BACKEND"] = "tensorflow"

import keras
import keras_nlp

# Run at half precision.
keras.config.set_floatx("bfloat16")

model_name = 'gemma_instruct_2b_en'
gemma_model = keras_nlp.models.GemmaCausalLM.from_preset(model_name)

Kode berikut menginisialisasi wrapper LIT untuk mendukung salience pada model Gemma. Framework LIT menyebutnya sebagai model, tetapi dalam hal ini, keduanya hanyalah endpoint yang berbeda untuk gemma_model dasar yang sama dengan yang Anda muat di atas. Hal ini memungkinkan LIT menghitung pembuatan, tokenisasi, dan salience sesuai permintaan.

from lit_nlp.examples.models import instrumented_keras_lms

batch_size = 1
max_sequence_length = 512
init_models = instrumented_keras_lms.initialize_model_group_for_salience
models = init_models(model_name, gemma_model,
                     batch_size=batch_size,
                     max_length=max_sequence_length)

Menyiapkan set data LIT

Gemma adalah model generatif teks-ke-teks yang mengambil input teks dan menghasilkan output teks. Model LIT mengasumsikan bahwa set data akan menyediakan kolom berikut untuk mendukung pembuatan:

  • prompt: Input ke KerasGenerationModel.
  • target: Urutan target opsional, seperti jawaban "kebenaran dasar" (gold) atau respons yang telah dibuat sebelumnya dari model.

LIT menyertakan kumpulan kecil sample_prompts dengan contoh dari beberapa sumber yang berbeda, seperti:

  • [GSM8K][GSM8K]: Menyelesaikan soal matematika di sekolah dasar dengan sedikit contoh.
  • [Gigaword Benchmark][gigaword]: Pembuatan judul untuk kumpulan artikel pendek.
  • [Prompt Konstitusional][Constitutional-prompting]: Menghasilkan ide baru tentang cara menggunakan objek dengan pedoman/batas

Anda juga dapat dengan mudah memuat data Anda sendiri, baik sebagai file .jsonl yang berisi data dengan kolom prompt dan secara opsional target ([example][jsonl-example]), atau dari format apa pun menggunakan Dataset API LIT.

Jalankan sel di bawah untuk memuat contoh perintah.

from lit_nlp.examples.datasets import lm as lm_data

datasets = {
  'sample_prompts': lm_data.PromptExamples(
      lm_data.PromptExamples.SAMPLE_DATA_PATH
  ),
}

Menyiapkan UI LIT

LIT adalah alat pemahaman model interaktif yang memungkinkan evaluasi yang memerlukan interaksi manusia dan pemeriksaan perilaku model. UI LIT memfasilitasi interaksi ini dengan memungkinkan Anda untuk:

  • memvisualisasikan set data dan output model secara langsung,
  • menjalankan metode salience untuk memahami perilaku model penggerak token input, dan
  • membuat kontrafaktual untuk menguji hipotesis.

LIT memungkinkan semuanya dalam antarmuka yang sama, sehingga mengurangi hambatan saat beralih antar-alat yang berbeda. Hal ini sangat berguna untuk tugas-tugas seperti prompt engineering, yang akan Anda fokuskan nanti dalam codelab ini.

Tata letak UI ini dapat digunakan untuk model bahasa generatif lainnya. Jika Anda tertarik dengan fitur selain yang tercantum di sini, Anda dapat menemukan daftar lengkapnya di sini.

from lit_nlp.api import layout
modules = layout.LitModuleName

LM_SALIENCE_LAYOUT = layout.LitCanonicalLayout(
    left={
        'Data Table': [modules.DataTableModule],
        'Datapoint Editor': [modules.DatapointEditorModule],
    },
    upper={  # if 'lower' not specified, this fills the right side
        'Salience': [modules.LMSalienceModule],
    },
    layoutSettings=layout.LayoutSettings(leftWidth=40),
    description='Custom layout for language model salience.',
)

Sel ini melakukan inisialisasi server LIT. Ini mungkin perlu waktu beberapa detik, karena juga menjalankan model pada contoh prompt dan meng-cache hasilnya.

from lit_nlp import notebook as lit_notebook

lit_widget = lit_notebook.LitWidget(
    models=models,
    datasets=datasets,
    layouts={'default': LM_SALIENCE_LAYOUT},
    default_layout='default',
)

Sekarang Anda dapat menampilkan UI:

lit_widget.render(height=800)

<IPython.core.display.Javascript object>

Anda juga dapat membuka LIT sebagai halaman penuh di tab baru. Jalankan sel ini dan klik link yang ditampilkan:

lit_widget.render(open_in_new_tab=True)

<IPython.core.display.Javascript object>

Menganalisis Beberapa Petunjuk untuk Gemma di LIT

Saat ini, prompting sama seperti sains, dan LIT dapat membantu Anda secara empiris meningkatkan prompt untuk model bahasa besar, seperti Gemma. Di depan, Anda akan melihat contoh cara menggunakan LIT untuk mempelajari perilaku Gemma, mengantisipasi potensi masalah, dan meningkatkan keamanannya.

Mengidentifikasi error dalam prompt yang kompleks

Dua teknik prompting yang paling penting untuk prototipe dan aplikasi berbasis LLM berkualitas tinggi adalah few-shot prompting (termasuk contoh perilaku yang diinginkan dalam prompt) dan rantai pikiran (termasuk bentuk penjelasan atau penalaran sebelum output akhir LLM). Tetapi membuat petunjuk yang efektif sering kali masih menantang.

Pertimbangkan contoh dalam membantu seseorang menilai apakah mereka akan menyukai makanan berdasarkan selera mereka. Prototipe awal {i>prompt-template<i} rantai-pemikiran mungkin terlihat seperti ini:

def analyze_menu_item_template(food_likes, food_dislikes, menu_item):
  return f"""Analyze a menu item in a restaurant.

## For example:

Taste-likes: I've a sweet-tooth
Taste-dislikes: Don't like onions or garlic
Suggestion: Onion soup
Analysis: it has cooked onions in it, which you don't like.
Recommendation: You have to try it.

Taste-likes: I've a sweet-tooth
Taste-dislikes: Don't like onions or garlic
Suggestion: Baguette maison au levain
Analysis: Home-made leaven bread in france is usually great
Recommendation: Likely good.

Taste-likes: I've a sweet-tooth
Taste-dislikes: Don't like onions or garlic
Suggestion: Macaron in france
Analysis: Sweet with many kinds of flavours
Recommendation: You have to try it.

## Now analyze one more example:

Taste-likes: {food_likes}
Taste-dislikes: {food_dislikes}
Suggestion: {menu_item}
Analysis:"""

Apakah Anda menemukan masalah pada {i>prompt<i} ini? LIT akan membantu Anda memeriksa perintah menggunakan modul Salience LM.

Menggunakan salience urutan untuk proses debug

Modul ini menyoroti bagian prompt yang diperhatikan model saat membuat jawabannya. Salience dihitung pada tingkat sekecil mungkin (yaitu, untuk setiap token input), tetapi LIT dapat menggabungkan token-saliency ke dalam span yang lebih besar dan lebih mudah ditafsirkan, seperti baris, kalimat, atau kata. Anda dapat mempelajari lebih lanjut saliency dan cara menggunakannya untuk mengidentifikasi bias yang tidak diinginkan di artikel Saliency Explorable.

Mari kita mulai dengan memberikan perintah sebuah contoh input baru untuk variabel prompt-template:

food_likes = """Cheese"""
food_dislikes = """Can't eat eggs"""
menu_item = """Quiche Lorraine"""

prompt = analyze_menu_item_template(food_likes, food_dislikes, menu_item)
print(prompt)

fewshot_mistake_example = {'prompt': prompt}  # you'll use this below

Analyze a menu item in a restaurant.

## For example:

Taste-likes: I've a sweet-tooth
Taste-dislikes: Don't like onions or garlic
Suggestion: Onion soup
Analysis: it has cooked onions in it, which you don't like.
Recommendation: You have to try it.

Taste-likes: I've a sweet-tooth
Taste-dislikes: Don't like onions or garlic
Suggestion: Baguette maison au levain
Analysis: Home-made leaven bread in france is usually great
Recommendation: Likely good.

Taste-likes: I've a sweet-tooth
Taste-dislikes: Don't like onions or garlic
Suggestion: Macaron in france
Analysis: Sweet with many kinds of flavours
Recommendation: You have to try it.

## Now analyze one more example:

Taste-likes: Cheese
Taste-dislikes: Can't eat eggs
Suggestion: Quiche Lorraine
Analysis:

Jika UI LIT terbuka di sel di atas atau di tab terpisah, Anda dapat menggunakan Datapoint Editor LIT untuk menambahkan permintaan ini:

1_Editor_Datapoint.png

Cara lainnya adalah merender ulang widget secara langsung dengan perintah yang diinginkan:

lit_widget.render(data=[fewshot_mistake_example])

<IPython.core.display.Javascript object>

Perhatikan bahwa penyelesaian model yang mengejutkan:

Taste-likes: Cheese
Taste-dislikes: Can't eat eggs
Suggestion: Quiche Lorraine
Analysis: A savoury tart with cheese and eggs
Recommendation: You might not like it, but it's worth trying.

Mengapa model menyarankan Anda untuk makan sesuatu yang jelas tidak boleh Anda makan?

{i>Salience <i}urutan dapat membantu menyoroti akar masalah, yang ada dalam contoh beberapa kesempatan. Pada contoh pertama, penalaran rantai pemikiran di bagian analisis it has cooked onions in it, which you don't like tidak cocok dengan rekomendasi akhir You have to try it.

Di modul LM Salience, pilih "Sentences", lalu pilih baris rekomendasi. UI kini akan terlihat seperti berikut:

3_few_shots_mistake..png

Sekarang, mari perbaiki "Rekomendasi" di contoh pertama menjadi Avoid, dan coba lagi. LIT memiliki contoh ini yang dimuat sebelumnya dalam contoh perintah, sehingga Anda dapat menggunakan fungsi utilitas kecil ini untuk mengambilnya:

def get_fewshot_example(source: str) -> str:
  for example in datasets['sample_prompts'].examples:
    if example['source'] == source:
      return example['prompt']
  raise ValueError(f'Source "{source}" not found in the dataset.')

lit_widget.render(data=[{'prompt': get_fewshot_example('fewshot-fixed')}])

<IPython.core.display.Javascript object>

Sekarang penyelesaian model menjadi:

Taste-likes: Cheese
Taste-dislikes: Can't eat eggs
Suggestion: Quiche Lorraine
Analysis: This dish contains eggs and cheese, which you don't like.
Recommendation: Avoid.

Pelajaran penting yang dapat diambil dari hal ini adalah: pembuatan prototipe awal membantu mengungkapkan risiko yang mungkin tidak terpikirkan sebelumnya, dan sifat model bahasa yang rentan terhadap error membuat kita harus secara proaktif mendesain untuk mengatasi error. Diskusi lebih lanjut tentang hal ini dapat ditemukan di Buku Panduan People + AI untuk mendesain dengan AI.

Meskipun beberapa perintah yang dikoreksi lebih baik, masih belum benar: Prompt tersebut memberi tahu pengguna untuk menghindari telur, tetapi alasannya tidak benar, dikatakan mereka tidak suka telur, padahal sebenarnya pengguna telah menyatakan bahwa mereka tidak bisa makan telur. Di bagian berikut, Anda akan mengetahui cara melakukannya dengan lebih baik.

Uji hipotesis untuk meningkatkan perilaku model

Dengan LIT, Anda dapat menguji perubahan pada perintah dalam antarmuka yang sama. Dalam instance ini, Anda akan menguji penambahan konstitusi untuk meningkatkan perilaku model. Konstitusi mengacu pada perintah desain dengan prinsip-prinsip untuk membantu memandu generasi model. Metode terbaru bahkan memungkinkan penurunan interaktif prinsip konstitusional.

Mari kita gunakan ide ini untuk membantu meningkatkan kualitas dialog lebih lanjut. Tambahkan bagian yang berisi prinsip-prinsip untuk generasi di bagian atas perintah, yang sekarang dimulai sebagai berikut:

Analyze a menu item in a restaurant.

* The analysis should be brief and to the point.
* The analysis and recommendation should both be clear about the suitability for someone with a specified dietary restriction.

## For example:

Taste-likes: I've a sweet-tooth
Taste-dislikes: Don't like onions or garlic
Suggestion: Onion soup
Analysis: it has cooked onions in it, which you don't like.
Recommendation: Avoid.

...


lit_widget.render(data=[{'prompt': get_fewshot_example('fewshot-constitution')}])

<IPython.core.display.Javascript object>

Dengan update ini, contoh dapat dijalankan kembali dan mengamati output yang sangat berbeda:

Taste-likes: Cheese
Taste-dislikes: Can't eat eggs
Suggestion: Quiche Lorraine
Analysis: This dish containts eggs, which you can't eat.
Recommendation: Not suitable for you.

{i>Prompt<i} yang menonjol kemudian dapat diperiksa ulang untuk membantu memahami mengapa perubahan ini terjadi:

3_few_shot_constitution.png

Perhatikan bahwa rekomendasi ini jauh lebih aman. Selain itu, kata "Tidak cocok untuk Anda" dipengaruhi oleh prinsip yang secara jelas menyatakan kesesuaian berdasarkan batasan diet, bersama dengan analisis (yang disebut rantai pemikiran). Hal ini membantu memberikan keyakinan tambahan bahwa output terjadi karena alasan yang tepat.

Menyertakan tim non-teknis dalam eksplorasi dan penyelidikan model

Penafsiran dimaksudkan sebagai upaya tim, yang mencakup keahlian dalam XAI, kebijakan, hukum, dan banyak lagi.

Berinteraksi dengan model dalam tahap pengembangan awal biasanya memerlukan keahlian teknis yang signifikan, sehingga menyulitkan beberapa kolaborator untuk mengakses dan menyelidikinya. Alat secara historis belum ada untuk memungkinkan tim ini berpartisipasi dalam fase pembuatan prototipe awal.

Melalui LIT, kami berharap paradigma ini dapat berubah. Seperti yang telah Anda lihat melalui codelab ini, media visual dan kemampuan interaktif LIT untuk memeriksa salience dan menjelajahi contoh dapat membantu berbagai pemangku kepentingan berbagi dan mengomunikasikan temuan. Hal ini memungkinkan Anda menghadirkan keberagaman rekan tim yang lebih luas untuk eksplorasi, pemeriksaan, dan proses debug model. Mengekspos metode teknis ini dapat meningkatkan pemahaman mereka tentang cara kerja model. Selain itu, keahlian yang lebih beragam dalam pengujian model awal juga dapat membantu menemukan hasil yang tidak diinginkan dan dapat ditingkatkan.

Recap

Ringkasnya:

  • UI LIT menyediakan antarmuka untuk eksekusi model interaktif, yang memungkinkan pengguna menghasilkan output secara langsung dan menguji skenario “bagaimana jika”. Hal ini sangat berguna untuk menguji berbagai variasi prompt.
  • Modul LM Salience memberikan representasi visual yang menonjol, dan memberikan perincian data yang dapat dikontrol sehingga Anda dapat berkomunikasi tentang konstruksi yang berpusat pada manusia (misalnya, kalimat dan kata), bukan konstruksi yang berpusat pada model (misalnya, token).

Setelah menemukan contoh bermasalah dalam evaluasi model, pindahkan contoh tersebut ke LIT untuk proses debug. Mulailah dengan menganalisis unit konten terbesar yang masuk akal yang menurut Anda secara logis terkait dengan tugas pemodelan, gunakan visualisasi untuk melihat di mana model benar atau salah menghadiri konten perintah, lalu lihat perincian unit konten yang lebih kecil untuk menjelaskan lebih lanjut perilaku salah yang Anda lihat untuk mengidentifikasi kemungkinan perbaikan.

Terakhir: Lit terus ditingkatkan! Pelajari lebih lanjut fitur kami dan bagikan saran Anda di sini.

Lampiran: Cara LIT Menghitung Pentingnya Urutan

LIT menghitung salience urutan dalam proses multi-langkah.

  1. Dengan mempertimbangkan string input (prompt dan pembuatan model atau urutan target "emas"), buat token untuk input model.
  2. Hitung urutan "target" dengan menggulir token input satu posisi ke kiri.
  3. Ekstrak embedding untuk dan hitung kerugian per token antara pembuatan dan urutan "target".
  4. Samarkan kerugian untuk mengisolasi token yang ingin Anda jelaskan.
  5. Gunakan fungsi tf.GradientTape.gradient() untuk menghitung gradien embeddings input terkait dengan kerugian yang disamarkan.
  6. Proses gradien untuk memberikan skor tunggal bagi setiap token input. Misalnya, dengan mengambil norma L2 dari gradien pada setiap posisi.

Lampiran: Menghitung Kepentingan Secara Terprogram

Skor salience dapat dihitung langsung dari Python, menggunakan langkah yang sama seperti langkah di atas yang dijalankan alat LIT secara internal. Anda akan melakukannya dalam tiga langkah:

  1. Siapkan contoh dan jalankan tokenizer model,
  2. Siapkan {i>mask<i} yang memilih token (yang diprediksi) mana yang akan dijelaskan,
  3. Panggil wrapper salience.

Membuat contoh input untuk LIT

{'prompt': 'Keras is a',
 'target': ' deep learning library for Python that provides a wide range of tools and functionalities for building, training, and evaluating deep learning models.\n\n**'}

Catatan tentang konvensi panggilan: tokenizer dan wrapper salience menggunakan Model API LIT, dengan fungsi .predict() mengambil daftar contoh (dikte) dan menampilkan generator respons (dik). Cara ini jauh lebih fleksibel saat bekerja dengan set data yang lebih besar atau model yang lebih lambat. Namun, hal ini berarti jika Anda hanya menginginkan prediksi pada satu contoh, kini Anda perlu menggabungkannya dengan sesuatu seperti: list(model.predict([example])[0]

Mendapatkan token sehingga Anda dapat memilih target penjelasan

array(['<bos>', 'K', 'eras', '▁is', '▁a', '▁deep', '▁learning',
       '▁library', '▁for', '▁Python', '▁that', '▁provides', '▁a', '▁wide',
       '▁range', '▁of', '▁tools', '▁and', '▁functionalities', '▁for',
       '▁building', ',', '▁training', ',', '▁and', '▁evaluating', '▁deep',
       '▁learning', '▁models', '.', '\n\n', '**'], dtype='<U16')

Untuk menghitung salience, Anda perlu membuat mask target yang menentukan token (yang diprediksi) mana yang akan dijelaskan. Mask target akan berupa array dengan panjang yang sama dengan token, dengan 1 pada posisi token yang ingin Anda jelaskan. Mari kita gunakan ▁training dan ▁evaluating sebagai target:

Siapkan mask target

{'prompt': 'Keras is a',
 'target': ' deep learning library for Python that provides a wide range of tools and functionalities for building, training, and evaluating deep learning models.\n\n**',
 'target_mask': array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
        0., 0., 0., 0., 0., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0.],
       dtype=float32)}

Memanggil model salience

{'grad_l2': array([45.75, 36.75, 61, 5.40625, 4.09375, 5.625, 6.46875, 7.3125, 3.375,
        5.03125, 3.23438, 4.5625, 2.375, 3.40625, 2.75, 1.97656, 3.95312,
        3.42188, 14.125, 4.53125, 11.375, 12.625, 18.5, 4.5625, 6.5, 0, 0,
        0, 0, 0, 0, 0], dtype=bfloat16),
 'grad_dot_input': array([-4.03125, 3.04688, -7.03125, -0.800781, 0.769531, -0.679688,
        -0.304688, 2.04688, 0.275391, -1.25781, -0.376953, -0.0664062,
        -0.0405273, -0.357422, 0.355469, -0.145508, -0.333984, 0.0181885,
        -5.0625, 0.235352, -0.470703, 2.25, 3.90625, -0.199219, 0.929688,
        0, 0, 0, 0, 0, 0, 0], dtype=bfloat16),
 'tokens': array(['<bos>', 'K', 'eras', '▁is', '▁a', '▁deep', '▁learning',
        '▁library', '▁for', '▁Python', '▁that', '▁provides', '▁a', '▁wide',
        '▁range', '▁of', '▁tools', '▁and', '▁functionalities', '▁for',
        '▁building', ',', '▁training', ',', '▁and', '▁evaluating', '▁deep',
        '▁learning', '▁models', '.', '\n\n', '**'], dtype='<U16')}

Dan, berhasil! Skor di kolom grad_l2 dan grad_dot_input disejajarkan dengan tokens, dan sama seperti yang akan Anda lihat di UI LIT.

Perhatikan bahwa beberapa skor terakhir adalah 0: karena model kita adalah model bahasa dari kiri ke kanan, token di sebelah kanan span target tidak memiliki pengaruh pada prediksi.