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

1. บทนำ

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

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

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

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

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

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

การสาธิต LIT UI

2. ความอิ่มตัวของลำดับและการนำไปใช้ในการวิเคราะห์โมเดล

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

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

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

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

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

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

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

หมายเหตุ: คุณอาจเห็นคำเตือนบางอย่างในแบบฟอร์ม

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 ด้วย

4. การตั้งค่าโมเดล 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 เพื่อรองรับความอิ่มตัวในโมเดล Gemma เฟรมเวิร์ก LIT อ้างอิงถึงโมเดลเหล่านี้แต่ในกรณีนี้เป็นเพียงปลายทางที่ต่างกันสำหรับ gemma_model พื้นฐานเดียวกันที่คุณโหลดด้านบน ซึ่งจะทำให้ LIT ประมวลผลการสร้าง การแปลงข้อมูลเป็นโทเค็น และความเค็มแบบออนดีมานด์ได้

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)

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

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

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

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

  • GSM8K: การแก้โจทย์คณิตศาสตร์ในโรงเรียนประถมด้วยตัวอย่างแบบช็อตสั้นๆ
  • การเปรียบเทียบ Gigaword: การสร้างพาดหัวสำหรับคอลเล็กชันบทความสั้นๆ
  • การแจ้งตามรัฐธรรมนูญ: สร้างแนวคิดใหม่ๆ เกี่ยวกับวิธีใช้ออบเจ็กต์ที่มีหลักเกณฑ์/ขอบเขต

นอกจากนี้ คุณยังโหลดข้อมูลของคุณเองได้ง่ายๆ โดยอาจเป็นไฟล์ .jsonl ที่มีระเบียนที่มีช่อง prompt และ target (ตัวอย่าง) ที่ไม่บังคับ หรือมาจากรูปแบบใดก็ได้โดยใช้ 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
  ),
}

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

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

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

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)

การสาธิต LIT UI

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

lit_widget.render(open_in_new_tab=True)

หมายเหตุ: หากคุณใช้ LIT ในสคริปต์ .py ปกติ ให้ใช้ lit_nlp.dev_server.Server() แทน LitWidget เพื่อเรียกใช้เซิร์ฟเวอร์แบบสแตนด์อโลน ดูรายละเอียดเพิ่มเติมได้ในเอกสารประกอบของ LIT

7. การวิเคราะห์พรอมต์ช็อตบางส่วนสำหรับ Gemma ใน LIT

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

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

เทคนิคการพรอมต์ที่สำคัญที่สุด 2 อย่างสำหรับต้นแบบและแอปพลิเคชันคุณภาพสูงที่ใช้ LLM คือการแจ้งอย่างรวดเร็ว (รวมถึงตัวอย่างพฤติกรรมที่ต้องการในพรอมต์) และเชนความคิด (รวมถึงรูปแบบคำอธิบายหรือการให้เหตุผลก่อนผลลัพธ์สุดท้ายของ 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 จะช่วยคุณตรวจสอบข้อความแจ้งด้วยโมดูล Salience ของ LM

8. ใช้ความต่อเนื่องของลำดับในการแก้ไขข้อบกพร่อง

ความสามารถในการคำนวณจะได้รับการคำนวณที่ระดับน้อยที่สุดที่เป็นไปได้ (เช่น สำหรับโทเค็นอินพุตแต่ละรายการ) แต่ LIT สามารถรวบรวมข้อมูลความอิ่มตัวของโทเค็นเป็นช่วงที่กว้างขึ้นซึ่งตีความได้มากขึ้น เช่น บรรทัด ประโยค หรือคำ ดูข้อมูลเพิ่มเติมเกี่ยวกับ Saliency Explorable และวิธีใช้งานเพื่อระบุอคติที่เกิดขึ้นโดยไม่ตั้งใจใน 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:

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

ผู้แก้ไข Datapoint LIT

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

lit_widget.render(data=[fewshot_mistake_example])

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

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

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

LIT Salience

ส่วนนี้ไฮไลต์ข้อผิดพลาดของมนุษย์ นั่นคือการคัดลอกและวางส่วนคำแนะนำโดยไม่ได้ตั้งใจ และอัปเดตไม่ได้

ตอนนี้มาแก้ไข "คำแนะนำ" ให้ถูกต้อง ในตัวอย่างแรกกับ 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')}])

ความสมบูรณ์ของโมเดลจะกลายเป็นดังนี้

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.

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

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

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

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

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

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

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

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

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

LIT Salience

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

10. รวมทีมที่ไม่เชี่ยวชาญด้านเทคนิคไว้ในการตรวจสอบและการสํารวจโมเดล

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

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

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

11. สรุป

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

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

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

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