ลองดูที่เก็บ Gemma Cookbook เพื่อฟังตัวอย่างการสร้างและปรับแต่ง ดูข้อมูลเพิ่มเติม

หน้านี้ได้รับการแปลโดย Cloud Translation API

การใช้ LIT เพื่อวิเคราะห์โมเดล Gemma ใน Keras

ดูใน Generative AI

เรียกใช้ใน Google Colab

ดูซอร์สบน GitHub

เรียนรู้ใน Codelab

เกริ่นนำ

ผลิตภัณฑ์ Generative AI ค่อนข้างใหม่ และลักษณะการทำงานของแอปพลิเคชันอาจแตกต่างกันไปมากกว่ารูปแบบซอฟต์แวร์เดิมๆ ซึ่งทำให้การตรวจสอบโมเดลแมชชีนเลิร์นนิงที่ใช้ ตรวจสอบตัวอย่างลักษณะการทำงานของโมเดล และตรวจสอบสิ่งที่น่าประหลาดใจถือเป็นเรื่องสำคัญ

เครื่องมือความสามารถในการตีความการเรียนรู้ (LIT; เว็บไซต์, GitHub) เป็นแพลตฟอร์มสำหรับการแก้ไขข้อบกพร่องและวิเคราะห์โมเดล ML เพื่อทำความเข้าใจสาเหตุและพฤติกรรมของโมเดล

ใน Codelab นี้ คุณจะได้เรียนรู้วิธีใช้ LIT เพื่อใช้ประโยชน์สูงสุดจากโมเดล Gemma ของ Google Codelab นี้จะสาธิตวิธีใช้ Salience Salience ซึ่งเป็นเทคนิคการตีความเชิงความหมาย เพื่อวิเคราะห์แนวทางด้านวิศวกรรมพรอมต์ต่างๆ

วัตถุประสงค์การเรียนรู้

การทำความเข้าใจ Salience ตามลำดับและการใช้ในการวิเคราะห์โมเดล
การตั้งค่า LIT สำหรับ Gemma เพื่อคำนวณเอาต์พุตพรอมต์และ Salience ตามลำดับ
การใช้ Salience ตามลำดับผ่านโมดูล LM Salience เพื่อทำความเข้าใจผลกระทบของการออกแบบพรอมต์ในเอาต์พุตโมเดล
ทดสอบการปรับปรุงพรอมต์ที่ตั้งสมมติฐานใน LIT และดูผลกระทบที่เกิดขึ้น

หมายเหตุ: Codelab นี้ใช้การติดตั้งใช้งาน KerasNLP ของ Gemma และ TensorFlow v2 สำหรับแบ็กเอนด์ เราขอแนะนำให้ใช้เคอร์เนล GPU เพื่อติดตามผล

Salience ลำดับและการนำไปใช้ในการวิเคราะห์โมเดล

โมเดลสร้างจากข้อความเป็นข้อความ เช่น Gemma จะใช้ลำดับอินพุตในรูปแบบข้อความที่แปลงข้อมูลเป็นโทเค็น และสร้างโทเค็นใหม่ที่เป็นการติดตามผลตามปกติหรือการเสร็จสิ้นอินพุตนั้น การสร้างนี้จะเกิดขึ้นครั้งละ 1 โทเค็นโดยใส่โทเค็นที่สร้างใหม่แต่ละรายการ (วนซ้ำ) ลงในอินพุต รวมถึงรุ่นก่อนๆ จนกว่าโมเดลจะมีเงื่อนไขถึงการหยุด ตัวอย่างเช่น เมื่อโมเดลสร้างโทเค็นสิ้นสุดลำดับ (EOS) หรือถึงความยาวสูงสุดที่กำหนดไว้ล่วงหน้า

เมธอด Salience คือคลาสของเทคนิค AI (XAI) ที่อธิบายได้ซึ่งสามารถบอกคุณได้ว่าส่วนใดของอินพุตที่มีความสำคัญต่อโมเดลสำหรับส่วนต่างๆ ของเอาต์พุต LIT รองรับเมธอดการเลื่อนระดับสำหรับงานการแยกประเภทที่หลากหลาย ซึ่งอธิบายผลกระทบของลำดับโทเค็นอินพุตในป้ายกำกับที่คาดการณ์ไว้ Salience ตามลำดับทำให้วิธีการเหล่านี้ใช้โมเดลการสร้างแบบข้อความเป็นข้อความทั่วไป และอธิบายผลกระทบที่โทเค็นก่อนหน้ามีต่อโทเค็นที่สร้างขึ้น

คุณจะใช้เมธอด Grad L2 Norm ที่นี่สำหรับ Salience ตามลำดับ ซึ่งจะวิเคราะห์การไล่ระดับสีของโมเดลและให้สัดส่วนของอิทธิพลที่โทเค็นก่อนหน้าแต่ละรายการมีต่อเอาต์พุต วิธีนี้ง่ายและมีประสิทธิภาพ และแสดงให้เห็นว่าทำงานได้ดีในการจัดหมวดหมู่และการตั้งค่าอื่นๆ ยิ่งคะแนนความอิ่มตัวสูง มีผลมากเท่าใด วิธีนี้ใช้ใน LIT เนื่องจากเข้าใจเป็นอย่างดีและนำไปใช้อย่างกว้างขวางในชุมชนการวิจัยความสามารถในการตีความ

วิธีการแบบซาลิ่งของการไล่ระดับสีขั้นสูงเพิ่มเติม ได้แก่ Grad ⋅ อินพุต และการไล่ระดับสีที่ผสานรวม นอกจากนี้ยังมีวิธีที่ใช้การหักล้าง เช่น LIME และ SHAP ซึ่งมีประสิทธิภาพมากกว่าแต่แพงกว่าในการประมวลผล อ่านข้อมูลในบทความนี้เพื่อเปรียบเทียบรายละเอียดของวิธีทำแบบสาดน้ำ

ดูข้อมูลเพิ่มเติมเกี่ยวกับวิทยาศาสตร์ของวิธีการแบบ Salience ได้ในการทดลองแบบอินเทอร์แอกทีฟเบื้องต้นที่สำรวจได้ด้วย Salience

การนำเข้า สภาพแวดล้อม และรหัสการตั้งค่าอื่นๆ

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.

คุณไม่ต้องสนใจอะไรอีก

ติดตั้ง LIT และ Keras NLP

สำหรับ Codelab นี้ คุณจะต้องใช้ keras (3) keras-nlp (0.8.0) และ lit-nlp (1.1) เวอร์ชันล่าสุด รวมถึงบัญชี Kaggle เพื่อดาวน์โหลดโมเดลฐาน

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

สิทธิ์การเข้าถึง Kaggle

หากต้องการเข้าสู่ระบบ Kaggle คุณสามารถจัดเก็บไฟล์ข้อมูลเข้าสู่ระบบ kaggle.json ไว้ที่ ~/.kaggle/kaggle.json หรือเรียกใช้โปรแกรมต่อไปนี้ในสภาพแวดล้อม Colab ก็ได้ ดูรายละเอียดเพิ่มเติมในเอกสารประกอบเกี่ยวกับแพ็กเกจของ kagglehub

import kagglehub

kagglehub.login()

โปรดอย่าลืมยอมรับข้อตกลงการอนุญาตให้ใช้สิทธิของ Gemma ด้วย

กำลังตั้งค่า LIT สำหรับ Gemma

การตั้งค่าโมเดล 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)

โค้ดต่อไปนี้จะเริ่มต้น LIT Wrapper เพื่อรองรับ Salience ในโมเดล Gemma เฟรมเวิร์ก LIT จะเรียกรายการเหล่านี้ว่าเป็นโมเดล แต่ในกรณีนี้เป็นเพียงปลายทางที่ต่างกันสำหรับ gemma_model เบื้องหลังเดียวกันที่คุณโหลดไว้ด้านบน ซึ่งช่วยให้ LIT สามารถประมวลผลการสร้าง การแปลงข้อมูลเป็นโทเค็น และ Salience แบบออนดีมานด์

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)

การตั้งค่าชุดข้อมูล LIT

Gemma เป็นโมเดลการสร้างข้อความให้เป็นข้อความ ซึ่งจะใช้การป้อนข้อความและสร้างเอาต์พุตข้อความ โมเดลของ LIT จะถือว่าชุดข้อมูลจะมีช่องต่อไปนี้เพื่อรองรับการสร้าง

prompt: อินพุตไปยัง KerasGenerationModel
target: ลำดับเป้าหมายที่ไม่บังคับ เช่น คำตอบ "ข้อมูลจากการสังเกตการณ์โดยตรง" (ทอง) หรือคำตอบที่สร้างขึ้นล่วงหน้าจากโมเดล

LIT ประกอบด้วยชุด sample_prompts ขนาดเล็กพร้อมด้วยตัวอย่างจากแหล่งที่มาต่างๆ เช่น

[GSM8K][GSM8K]: การแก้ปัญหาคณิตศาสตร์ระดับประถมศึกษาด้วยตัวอย่างการถ่ายแบบ 2-3 ครั้ง
[Gigaword Comparison][gigaword]: การสร้างพาดหัวสำหรับคอลเล็กชันบทความสั้นๆ
[ข้อความแจ้งทางรัฐธรรมนูญ][คำสั่งรัฐธรรมนูญ]: การสร้างแนวคิดใหม่ๆ เกี่ยวกับวิธีใช้วัตถุกับหลักเกณฑ์/ขอบเขต

นอกจากนี้ คุณยังโหลดข้อมูลของตัวเองได้ง่ายๆ ไม่ว่าจะเป็นไฟล์ .jsonl ที่มีระเบียนที่มีช่อง prompt และอาจเลือก target([ตัวอย่าง][jsonl-example]) หรือจากรูปแบบใดก็ได้โดยใช้ Dataset API ของ LIT

เรียกใช้เซลล์ด้านล่างเพื่อโหลดพรอมต์ตัวอย่าง

from lit_nlp.examples.datasets import lm as lm_data

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

การตั้งค่า LIT UI

LIT เป็นเครื่องมือการทำความเข้าใจโมเดลแบบอินเทอร์แอกทีฟ ซึ่งช่วยให้ประเมินผลและการตรวจสอบพฤติกรรมของโมเดลด้วยมนุษย์ได้อย่างหลีกเลี่ยงไม่ได้ LIT UI ช่วยให้เกิดการโต้ตอบนี้ โดยช่วยให้คุณทำสิ่งต่อไปนี้ได้

แสดงภาพชุดข้อมูลและเอาต์พุตโมเดลแบบเรียลไทม์
เรียกใช้เมธอด Salience เพื่อทำความเข้าใจพฤติกรรมของโมเดลขับเคลื่อนโทเค็นอินพุต และ
สร้างข้อโต้แย้งที่ถูกต้อง เพื่อทดสอบสมมติฐาน

LIT ช่วยให้ทั้งหมดนี้ทำงานภายในอินเทอร์เฟซเดียวกันได้ จึงลดความยุ่งยากในการสลับใช้เครื่องมือต่างๆ ซึ่งจะมีประโยชน์มากสำหรับงานต่างๆ เช่น การสร้างพรอมต์วิศวกรรม ซึ่งจะเน้นทำภายหลังใน Codelab นี้

เลย์เอาต์ UI นี้สามารถใช้กับโมเดลภาษาแบบ Generative อื่นๆ ได้ หากสนใจฟีเจอร์ต่างๆ นอกเหนือจากที่ระบุไว้ที่นี่ ดูรายการฟีเจอร์ทั้งหมดได้ที่นี่

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.',
)

เซลล์นี้เริ่มต้นเซิร์ฟเวอร์ LIT อาจใช้เวลา 2-3 วินาที เนื่องจากจะเรียกใช้โมเดลในพรอมต์ตัวอย่างและแคชผลลัพธ์ด้วย

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',
)

ตอนนี้คุณสามารถแสดง UI ได้แล้ว ดังนี้

lit_widget.render(height=800)

<IPython.core.display.Javascript object>

คุณยังเปิด LIT เป็นหน้าแบบเต็มในแท็บใหม่ได้ด้วย เรียกใช้เซลล์นี้และคลิกลิงก์ที่แสดง

lit_widget.render(open_in_new_tab=True)

<IPython.core.display.Javascript object>

วิเคราะห์พรอมต์ช็อตน้อยลงสำหรับ Gemma ใน LIT

ปัจจุบันข้อความแจ้งมีความเป็นศิลปะมากพอๆ กับวิทยาศาสตร์ และ LIT ช่วยคุณปรับปรุงข้อความแจ้งสำหรับโมเดลภาษาขนาดใหญ่อย่างเช่น Gemma ได้อย่างแท้จริง ต่อไปคุณจะเห็นตัวอย่างวิธีใช้ LIT เพื่อสำรวจพฤติกรรมของ Gemma, คาดการณ์ปัญหาที่อาจเกิดขึ้น และปรับปรุงความปลอดภัย

ระบุข้อผิดพลาดในพรอมต์ที่ซับซ้อน

เทคนิคการเตือนที่สำคัญ 2 อย่างสำหรับต้นแบบและแอปพลิเคชันคุณภาพสูงที่ใช้ LLM คือข้อความแจ้ง 2-3 ครั้ง (รวมถึงตัวอย่างลักษณะการทำงานที่ต้องการในพรอมต์) และเชนความคิด (รวมถึงรูปแบบการอธิบายหรือการให้เหตุผลก่อนแสดงผลลัพธ์สุดท้ายของ LLM) แต่การสร้างข้อความแจ้งที่มีประสิทธิภาพก็มักทำได้ยาก

ลองดูตัวอย่างที่ช่วยประเมินว่าจะชอบอาหารตามความชอบหรือไม่ เทมเพลตพรอมต์แนวคิดห่วงโซ่ความคิดเริ่มต้นต้นแบบอาจมีลักษณะดังนี้

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:"""

คุณพบปัญหาเกี่ยวกับข้อความแจ้งนี้ไหม LIT จะช่วยคุณตรวจสอบพรอมต์โดยใช้โมดูล LM Salience

ใช้ Salience ของลำดับเพื่อแก้ไขข้อบกพร่อง

โมดูลนี้จะไฮไลต์ส่วนของพรอมต์ที่โมเดลเข้าร่วมเมื่อสร้างคำตอบ Salience ได้รับการคำนวณที่ระดับที่เล็กที่สุด (กล่าวคือ สำหรับโทเค็นอินพุตแต่ละโทเค็น) แต่ LIT สามารถรวมความรับรู้ของโทเค็นไว้โดยครอบคลุมครอบคลุมช่วงต่างๆ ที่กว้างมากขึ้น เช่น บรรทัด ประโยค หรือคำ ดูข้อมูลเพิ่มเติมเกี่ยวกับความสม่ำเสมอและวิธีใช้เพื่อระบุอคติที่เกิดขึ้นโดยไม่ตั้งใจได้ใน Saliency Explorable

เริ่มต้นด้วยการให้ตัวอย่างอินพุตใหม่แก่พรอมต์สำหรับตัวแปรของเทมเพลตพรอมต์ ดังนี้

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:

หากคุณเปิด UI ของ LIT ในเซลล์ด้านบนหรือในแท็บแยกต่างหาก ให้ใช้เครื่องมือแก้ไขจุดข้อมูลของ LIT เพื่อเพิ่มข้อความแจ้งนี้

เครื่องมือแก้ไขข้อมูล

อีกวิธีหนึ่งคือการแสดงผลวิดเจ็ตอีกครั้งโดยตรงพร้อมการแจ้งเตือนว่าสนใจ โดยทำดังนี้

lit_widget.render(data=[fewshot_mistake_example])

<IPython.core.display.Javascript object>

โปรดสังเกตการดำเนินการโมเดลที่น่าประหลาดใจ:

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.

ทำไมโมเดลจึงแนะนำให้คุณกินบางอย่างที่คุณบอกอย่างชัดเจนว่ากินไม่ได้

ความต่อเนื่องของลำดับสามารถช่วยไฮไลต์ปัญหาที่แท้จริง ซึ่งตัวอย่างเล็กๆ น้อยๆ ของเรานี้ ในตัวอย่างแรก การให้เหตุผลเกี่ยวกับห่วงโซ่ความคิดในส่วนการวิเคราะห์ it has cooked onions in it, which you don't like ไม่ตรงกับคำแนะนำสุดท้าย You have to try it

ในโมดูล LM Salience ให้เลือก "ประโยค" แล้วเลือกบรรทัดคำแนะนำ UI ควรมีลักษณะดังต่อไปนี้

ตอนนี้เรามาแก้ไข "คำแนะนำ" ในตัวอย่างแรกเป็น Avoid แล้วลองใหม่ LIT โหลดตัวอย่างนี้ไว้ล่วงหน้าแล้วในพรอมต์ตัวอย่าง เพื่อให้คุณใช้ฟังก์ชันยูทิลิตีเล็กๆ นี้เพื่อจับค่านี้ได้

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>

ในตอนนี้ การเสร็จสิ้นโมเดลจะกลายเป็น:

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.

บทเรียนสำคัญที่ควรหลีกเลี่ยงก็คือการสร้างต้นแบบในช่วงแรกช่วยเปิดเผยความเสี่ยงที่คุณอาจไม่ได้นึกถึงล่วงหน้า และลักษณะรูปแบบภาษาที่มีแนวโน้มเกิดข้อผิดพลาดได้ง่ายคือการออกแบบให้ตรวจหาข้อผิดพลาดในเชิงรุก ดูการพูดคุยเพิ่มเติมเกี่ยวกับเรื่องนี้ได้ในคู่มือบุคคลและ AI เกี่ยวกับการออกแบบด้วย AI

ข้อความแจ้ง 2-3 ช็อตที่แก้ไขแล้วยังไม่ค่อยถูกต้อง คือจะบอกผู้ใช้ให้หลีกเลี่ยงไข่ แต่เหตุผลที่ให้นั้นไม่ถูกต้อง ผู้ใช้บอกว่าไม่ชอบไข่ ทั้งๆ ที่ผู้ใช้บอกว่ากินไข่ไม่ได้ ในส่วนต่อไปนี้ คุณจะเห็นวิธีการปรับปรุง

ทดสอบสมมติฐานเพื่อปรับปรุงพฤติกรรมของโมเดล

LIT ช่วยให้คุณทดสอบการเปลี่ยนแปลงข้อความแจ้งภายในอินเทอร์เฟซเดียวกันได้ ในตัวอย่างนี้ คุณจะได้ทดสอบการเพิ่มรัฐธรรมนูญเพื่อปรับปรุงลักษณะการทำงานของโมเดล รัฐธรรมนูญหมายถึงคำสั่งในการออกแบบ ที่มีหลักการเพื่อช่วยแนะแนวทางในการสร้างโมเดล วิธีการล่าสุดยังเปิดใช้การต่อยอดแบบอินเทอร์แอกทีฟของหลักการทางรัฐธรรมนูญได้ด้วย

เรามาใช้แนวคิดนี้เพื่อปรับปรุงข้อความแจ้งต่อไป เพิ่มส่วนที่มีหลักการสำหรับผู้สร้างไว้ที่ด้านบนของพรอมต์ของเรา ซึ่งจะเริ่มต้นดังต่อไปนี้

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>

การอัปเดตนี้จะเรียกใช้ตัวอย่างได้อีกครั้งและสังเกตผลลัพธ์ที่ต่างกันมาก

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.

จากนั้นจะสามารถตรวจสอบระดับของข้อความแจ้งอีกครั้งเพื่อให้ทราบถึงสาเหตุที่เกิดการเปลี่ยนแปลงเช่นนี้ขึ้น

สังเกตเห็นว่าคำแนะนำปลอดภัยขึ้นมาก นอกจากนี้ คําว่า "ไม่เหมาะสำหรับคุณ" ยังได้รับอิทธิพลจากหลักการของการระบุความเหมาะสมตามข้อจํากัดด้านอาหารอย่างชัดเจนพร้อมด้วยการวิเคราะห์ (สิ่งที่เรียกว่า "ห่วงโซ่ความคิด) ซึ่งจะช่วยให้มั่นใจมากขึ้นว่าผลลัพธ์เกิดขึ้นด้วยเหตุผลที่เหมาะสม

รวมทีมที่ไม่ใช่ทีมเทคนิคในการตรวจสอบโมเดลและการสำรวจ

ความสามารถในการตีความคือการทำงานเป็นทีม รวมถึงความเชี่ยวชาญทั่วทั้ง XAI, นโยบาย, กฎหมาย และอื่นๆ

การโต้ตอบกับโมเดลในขั้นตอนการพัฒนาช่วงแรกมักต้องใช้ความเชี่ยวชาญทางเทคนิคอย่างมาก ซึ่งทำให้ผู้ทำงานร่วมกันบางรายเข้าถึงและตรวจสอบได้ยากขึ้น ก่อนหน้านี้เครื่องมือไม่มีปัจจุบันที่ช่วยให้ทีมเหล่านี้มีส่วนร่วมในระยะเริ่มต้นสร้างต้นแบบได้

การใช้ LIT ทำให้กระบวนทัศน์นี้สามารถเปลี่ยนแปลงได้ คุณจะเห็นจาก Codelab นี้ สื่อแบบภาพและความสามารถในการโต้ตอบของ LIT ในการตรวจสอบความอิ่มตัวและสำรวจตัวอย่างสามารถช่วยให้ผู้มีส่วนเกี่ยวข้องต่างๆ แชร์และสื่อสารผลการสืบค้นได้ วิธีนี้จะช่วยให้คุณนำเพื่อนร่วมทีมมีความหลากหลายมากขึ้นสำหรับการสำรวจ ตรวจสอบ และแก้ไขข้อบกพร่องของโมเดล การแสดงให้พวกเขาเห็นวิธีทางเทคนิคเหล่านี้ ช่วยเพิ่มความเข้าใจเกี่ยวกับวิธีการทำงานของโมเดลได้ นอกจากนี้ ความเชี่ยวชาญที่หลากหลายมากขึ้นในการทดสอบโมเดลขั้นต้นยังช่วยให้ค้นพบผลลัพธ์ที่ไม่พึงประสงค์ซึ่งปรับปรุงให้ดีขึ้นได้

สรุป

กล่าวโดยสรุปคือ

LIT UI มีอินเทอร์เฟซสำหรับดำเนินการกับโมเดลแบบอินเทอร์แอกทีฟ ช่วยให้ผู้ใช้สร้างเอาต์พุตได้โดยตรงและทดสอบสถานการณ์ "ถ้าหาก" วิธีนี้มีประโยชน์อย่างยิ่งสำหรับการทดสอบข้อความแจ้งรูปแบบต่างๆ
โมดูล LM Salience นำเสนอภาพของ Salience และให้รายละเอียดของข้อมูลที่ควบคุมได้ คุณจึงสามารถสื่อสารเกี่ยวกับโครงสร้างที่มีมนุษย์เป็นศูนย์กลาง (เช่น ประโยคและคำ) แทนโครงสร้างที่มีโมเดลเป็นศูนย์กลาง (เช่น โทเค็น)

เมื่อพบตัวอย่างที่เป็นปัญหาในการประเมินโมเดล ให้นำตัวอย่างดังกล่าวไปไว้ใน LIT เพื่อแก้ไขข้อบกพร่อง เริ่มต้นด้วยการวิเคราะห์หน่วยเนื้อหาที่สำคัญที่สุดซึ่งคุณคิดว่ามีความเกี่ยวข้องกับงานโมเดลอย่างมีตรรกะ โดยใช้การแสดงภาพเพื่อดูว่าโมเดลเข้าร่วมเนื้อหาในข้อความแจ้งอย่างถูกต้องหรือไม่ถูกต้อง จากนั้นเจาะลึกลงในหน่วยเนื้อหาเล็กๆ เพื่ออธิบายลักษณะการทำงานที่ไม่ถูกต้องที่คุณเห็นเพิ่มเติม เพื่อระบุการแก้ไขที่เป็นไปได้

สุดท้าย: Lit พัฒนาขึ้นเรื่อยๆ ดูข้อมูลเพิ่มเติมเกี่ยวกับฟีเจอร์ต่างๆ และแชร์ คำแนะนำของคุณได้ที่นี่

ภาคผนวก: วิธีที่ LIT คำนวณความอิ่มตัวของลำดับ

LIT จะคำนวณความต่อเนื่องของลำดับในกระบวนการที่มีหลายขั้นตอน

โดยระบุสตริงอินพุต (พรอมต์และการสร้างโมเดลหรือลำดับเป้าหมาย "gold") ทำให้เป็นโทเค็นสำหรับอินพุตโมเดล
คำนวณลำดับ "เป้าหมาย" โดยกลิ้งโทเค็นอินพุตไปทางซ้าย 1 ตำแหน่ง
ดึงข้อมูลการฝังสำหรับและคำนวณการสูญเสียต่อโทเค็นระหว่างลำดับการสร้างและ "เป้าหมาย"
ป้องกันการสูญเสียเพื่อแยกโทเค็นที่คุณสนใจอธิบาย
ใช้ฟังก์ชัน tf.GradientTape.gradient() เพื่อคำนวณการไล่ระดับสีของอินพุตที่ฝังที่เกี่ยวข้องกับการสูญเสียมาสก์
ประมวลผลการไล่ระดับสีเพื่อให้โทเค็นอินพุตแต่ละรายการมีคะแนนเดียว ตัวอย่างเช่น ด้วยการใช้ค่าปกติ L2 ของการไล่ระดับสีที่แต่ละตำแหน่ง

ภาคผนวก: การคำนวณ Salience แบบเป็นโปรแกรม

คุณจะคำนวณคะแนน Salience ได้โดยตรงจาก Python โดยใช้ขั้นตอนเดียวกับที่เครื่องมือ LIT เรียกใช้ภายใน ซึ่งจะมี 3 ขั้นตอนดังนี้

เตรียมตัวอย่างและเรียกใช้เครื่องมือแปลงข้อมูลโมเดล
เตรียมมาสก์ที่เลือกโทเค็น (ที่คาดการณ์) เพื่ออธิบาย
เรียก Salience Wrapper

สร้างตัวอย่างการป้อนข้อมูลสำหรับ LIT

example = {
    '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**'
}
example

{'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**'}

หมายเหตุเกี่ยวกับรูปแบบการเรียก: ทั้งเครื่องมือแปลงโทเค็นและ Wrapper ของซาลิซอร์จะใช้ Model API ของ LIT ซึ่งฟังก์ชัน .predict() จะแสดงรายการตัวอย่าง (คำสั่ง) และแสดงผลตัวสร้างคำตอบ (คำสั่ง) การดำเนินการนี้จะมีความยืดหยุ่นมากขึ้นเมื่อทำงานกับชุดข้อมูลขนาดใหญ่หรือโมเดลที่ช้ากว่า แต่หมายความว่าหากต้องการเพียงการคาดการณ์สำหรับตัวอย่างเดียว ตอนนี้คุณจะต้องรวมชุดข้อมูลดังกล่าวด้วยคำสั่งต่อไปนี้ list(model.predict([example])[0]

รับโทเค็นเพื่อให้คุณเลือกเป้าหมายคำอธิบายได้

tokenizer = models[f"_{model_name}_tokenizer"].predict
tokens = list(tokenizer([example]))[0]['tokens']
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')

หากต้องการคำนวณ Salience คุณต้องสร้างมาสก์เป้าหมายซึ่งระบุโทเค็น (ที่คาดการณ์) ที่จะอธิบาย มาสก์เป้าหมายจะเป็นอาร์เรย์ที่มีความยาวเท่ากับโทเค็น โดยมีเลข 1 ในตำแหน่งของโทเค็นที่คุณต้องการอธิบาย เราจะใช้ ▁training และ ▁evaluating เป็นเป้าหมาย

เตรียมมาสก์เป้าหมาย

import numpy as np

target_start = list(tokens).index("▁training")
target_end = list(tokens).index("▁evaluating")

# Prepare our mask
target_mask = np.zeros(len(tokens), dtype=np.float32)
target_mask[target_start:target_end+1] = 1
target_mask

# Add to our LIT input
example_for_salience = example | {'target_mask': target_mask}
example_for_salience

{'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)}

เรียกโมเดลแบบ Salience

compute_salience = models[f"_{model_name}_salience"].predict
salience = list(compute_salience([example_for_salience]))
salience[0]

{'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')}

เท่านี้ก็เรียบร้อย คะแนนในช่อง grad_l2 และ grad_dot_input จะสอดคล้องกับ tokens และตรงกับที่คุณเห็นใน UI ของ LIT

โปรดทราบว่าคะแนนล่าสุดสองสามรายการเป็น 0: เนื่องจากโมเดลของเราเป็นโมเดลภาษาที่อ่านจากซ้ายไปขวา โทเค็นที่อยู่ด้านขวาของช่วงเป้าหมายจะไม่มีผลต่อการคาดการณ์