การแสดงตัวแยกประเภทด้านความปลอดภัยแบบคล่องตัวด้วย Gemma

1. ภาพรวม

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

โค้ดแล็บนี้ใช้วิธีการ PET ของ LoRA และ Gemma รุ่นที่เล็กกว่า (gemma_instruct_2b_en) เนื่องจากสามารถทำงานได้เร็วขึ้นและมีประสิทธิภาพมากขึ้น โคแลบนี้จะอธิบายขั้นตอนการนำเข้าข้อมูล การจัดรูปแบบข้อมูลสำหรับ LLM การฝึกน้ำหนัก LoRA และการประเมินผลลัพธ์ โค้ดแล็บนี้ฝึกด้วยชุดข้อมูล ETHOS ซึ่งเป็นชุดข้อมูลสําหรับตรวจหาวาจาแสดงความเกลียดชังซึ่งเผยแพร่ต่อสาธารณะ โดยสร้างจากความคิดเห็นใน YouTube และ Reddit เมื่อฝึกด้วยตัวอย่างเพียง 200 รายการ (1/4 ของชุดข้อมูล) จะได้ F1: 0.80 และ ROC-AUC: 0.78 ซึ่งสูงกว่า SOTA ที่รายงานในตารางอันดับในปัจจุบันเล็กน้อย (ณ วันที่เขียน 15 ก.พ. 2024) เมื่อฝึกด้วยตัวอย่างทั้งหมด 800 รายการ Like ได้คะแนน F1 เท่ากับ 83.74 และคะแนน ROC-AUC เท่ากับ 88.17 โดยทั่วไปแล้วโมเดลขนาดใหญ่ เช่น gemma_instruct_7b_en จะมีประสิทธิภาพดีกว่า แต่ค่าใช้จ่ายในการฝึกและการดำเนินการก็จะสูงขึ้นด้วย

คำเตือน: เนื่องจากโค้ดแล็บนี้พัฒนาตัวแยกประเภทความปลอดภัยเพื่อตรวจหาวาจาแสดงความเกลียดชัง ตัวอย่างและการประเมินผลลัพธ์จึงมีภาษาที่รุนแรง

2. การติดตั้งและการตั้งค่า

สําหรับโค้ดแล็บนี้ คุณจะต้องมี keras (3) เวอร์ชันล่าสุด, keras-nlp (0.8.0) และบัญชี Kaggle เพื่อดาวน์โหลดโมเดลพื้นฐาน

!pip install -q -U keras-nlp
!pip install -q -U keras

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

import kagglehub

kagglehub.login()

โค้ดแล็บนี้ได้รับการทดสอบโดยใช้ Tensorflow เป็นแบ็กเอนด์ Keras แต่คุณใช้ Tensorflow, Pytorch หรือ JAX ก็ได้

import os

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

3. โหลดชุดข้อมูล ETHOS

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

import pandas as pd

gh_root = 'https://raw.githubusercontent.com'
gh_repo = 'intelligence-csd-auth-gr/Ethos-Hate-Speech-Dataset'
gh_path = 'master/ethos/ethos_data/Ethos_Dataset_Binary.csv'
data_url = f'{gh_root}/{gh_repo}/{gh_path}'

df = pd.read_csv(data_url, delimiter=';')
df['hateful'] = (df['isHate'] >= df['isHate'].median()).astype(int)

# Shuffle the dataset.
df = df.sample(frac=1, random_state=32)

# Split into train and test.
df_train, df_test = df[:800],  df[800:]

# Display a sample of the data.
df.head(5)[['hateful', 'comment']]

คุณจะเห็นข้อมูลในลักษณะนี้

	ป้ายกำกับ	ความคิดเห็น
0	0	You said he but still not convinced this is a ...
1	0	well, looks like its time to have another child.
2	0	What if we send every men to mars to start a n...
3	1	It doesn't matter if you're black or white, ...
4	0	Who ever disliked this video should be ashamed...

4. ดาวน์โหลดและสร้างอินสแตนซ์โมเดล

คุณสามารถใช้โมเดล Gemma ได้หลายวิธีอย่างง่ายดายตามที่อธิบายไว้ในเอกสารประกอบ สิ่งที่ต้องทำใน Keras มีดังนี้

import keras
import keras_nlp

# For reproducibility purposes.
keras.utils.set_random_seed(1234)

# Download the model from Kaggle using Keras.
model = keras_nlp.models.GemmaCausalLM.from_preset('gemma_instruct_2b_en')

# Set the sequence length to a small enough value to fit in memory in Colab.
model.preprocessor.sequence_length = 128

คุณทดสอบว่าโมเดลทํางานอยู่ได้โดยการนําเสนอข้อความบางส่วน ดังนี้

model.generate('Question: what is the capital of France? ', max_length=32)

5. การเตรียมข้อความล่วงหน้าและโทเค็นตัวแบ่ง

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

Classify the following text into one of the following classes:[Positive,Negative]

Text: you look very nice today
Classification:

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

Classify the following text into one of the following classes:[Positive,Negative]
<separator>
Text: you look very nice today
<separator>
Prediction:

ซึ่งสามารถแยกออกมาได้โดยใช้ฟังก์ชันที่ประมวลผลข้อความล่วงหน้า ดังนี้

def preprocess_text(
    text: str,
    labels: list[str],
    instructions: str,
    separator: str,
) -> str:
  prompt = f'{instructions}:[{",".join(labels)}]'
  return separator.join([prompt, f'Text:{text}', 'Prediction:'])

ตอนนี้ หากคุณเรียกใช้ฟังก์ชันโดยใช้พรอมต์และข้อความเดียวกันกับก่อนหน้านี้ คุณควรได้ผลลัพธ์เดียวกัน

text = 'you look very nice today'

prompt = preprocess_text(
    text=text,
    labels=['Positive', 'Negative'],
    instructions='Classify the following text into one of the following classes',
    separator='\n<separator>\n',
)

print(prompt)

ซึ่งจะแสดงผลลัพธ์ดังนี้

Classify the following text into one of the following classes:[Positive,Negative]
<separator>
Text:well, looks like its time to have another child
<separator>
Prediction:

6. กระบวนการหลังการประมวลผลเอาต์พุต

เอาต์พุตของโมเดลคือโทเค็นที่มีความน่าจะเป็นต่างๆ โดยปกติแล้ว หากต้องการสร้างข้อความ คุณจะต้องเลือกโทเค็นที่มีความน่าจะเป็นสูงสุด 2-3 รายการ แล้วสร้างประโยค ย่อหน้า หรือแม้แต่เอกสารทั้งฉบับ อย่างไรก็ตาม สิ่งที่สำคัญจริงๆ สำหรับการจัดประเภทคือโมเดลเชื่อว่า Positive มีแนวโน้มมากกว่า Negative หรือในทางกลับกัน

เมื่อพิจารณาจากโมเดลที่คุณสร้างอินสแตนซ์ไว้ก่อนหน้านี้ คุณสามารถประมวลผลเอาต์พุตของโมเดลให้เป็นความน่าจะเป็นอิสระได้ว่าโทเค็นถัดไปคือ Positive หรือ Negative ดังนี้

import numpy as np


def compute_output_probability(
    model: keras_nlp.models.GemmaCausalLM,
    prompt: str,
    target_classes: list[str],
) -> dict[str, float]:
  # Shorthands.
  preprocessor = model.preprocessor
  tokenizer = preprocessor.tokenizer

  # NOTE: If a token is not found, it will be considered same as "<unk>".
  token_unk = tokenizer.token_to_id('<unk>')

  # Identify the token indices, which is the same as the ID for this tokenizer.
  token_ids = [tokenizer.token_to_id(word) for word in target_classes]

  # Throw an error if one of the classes maps to a token outside the vocabulary.
  if any(token_id == token_unk for token_id in token_ids):
    raise ValueError('One of the target classes is not in the vocabulary.')

  # Preprocess the prompt in a single batch. This is done one sample at a time
  # for illustration purposes, but it would be more efficient to batch prompts.
  preprocessed = model.preprocessor.generate_preprocess([prompt])

  # Identify output token offset.
  padding_mask = preprocessed["padding_mask"]
  token_offset = keras.ops.sum(padding_mask) - 1

  # Score outputs, extract only the next token's logits.
  vocab_logits = model.score(
      token_ids=preprocessed["token_ids"],
      padding_mask=padding_mask,
  )[0][token_offset]

  # Compute the relative probability of each of the requested tokens.
  token_logits = [vocab_logits[ix] for ix in token_ids]
  logits_tensor = keras.ops.convert_to_tensor(token_logits)
  probabilities = keras.activations.softmax(logits_tensor)

  return dict(zip(target_classes, probabilities.numpy()))

คุณสามารถทดสอบฟังก์ชันดังกล่าวได้โดยเรียกใช้กับพรอมต์ที่คุณสร้างไว้ก่อนหน้านี้

compute_output_probability(
    model=model,
    prompt=prompt,
    target_classes=['Positive', 'Negative'],
)

ซึ่งจะแสดงผลลัพธ์ที่คล้ายกับตัวอย่างต่อไปนี้

{'Positive': 0.99994016, 'Negative': 5.984089e-05}

7. สรุปทั้งหมดเป็น Classfier

คุณสามารถรวมฟังก์ชันทั้งหมดที่เพิ่งสร้างขึ้นไว้ในตัวแยกประเภทที่คล้ายกับ sklearn รายการเดียวเพื่อให้ใช้งานง่ายด้วยฟังก์ชันที่ใช้งานง่ายและคุ้นเคย เช่น predict() และ predict_score()

import dataclasses


@dataclasses.dataclass(frozen=True)
class AgileClassifier:
  """Agile classifier to be wrapped around a LLM."""

  # The classes whose probability will be predicted.
  labels: tuple[str, ...]

  # Provide default instructions and control tokens, can be overridden by user.
  instructions: str = 'Classify the following text into one of the following classes'
  separator_token: str = '<separator>'
  end_of_text_token: str = '<eos>'

  def encode_for_prediction(self, x_text: str) -> str:
    return preprocess_text(
        text=x_text,
        labels=self.labels,
        instructions=self.instructions,
        separator=self.separator_token,
    )

  def encode_for_training(self, x_text: str, y: int) -> str:
    return ''.join([
        self.encode_for_prediction(x_text),
        self.labels[y],
        self.end_of_text_token,
    ])

  def predict_score(
      self,
      model: keras_nlp.models.GemmaCausalLM,
      x_text: str,
  ) -> list[float]:
    prompt = self.encode_for_prediction(x_text)
    token_probabilities = compute_output_probability(
        model=model,
        prompt=prompt,
        target_classes=self.labels,
    )
    return [token_probabilities[token] for token in self.labels]

  def predict(
      self,
      model: keras_nlp.models.GemmaCausalLM,
      x_eval: str,
  ) -> int:
    return np.argmax(self.predict_score(model, x_eval))


agile_classifier = AgileClassifier(labels=('Positive', 'Negative'))

8. การปรับแต่งโมเดล

LoRA ย่อมาจาก Low-Rank Adaptation ซึ่งเป็นเทคนิคการปรับแต่งที่สามารถใช้เพื่อปรับแต่งโมเดลภาษาขนาดใหญ่ได้อย่างมีประสิทธิภาพ คุณสามารถอ่านข้อมูลเพิ่มเติมได้ในบทความ LoRA: Low-Rank Adaptation of Large Language Models

การใช้งาน Gemma ของ Keras มีเมธอด enable_lora() ที่คุณสามารถใช้เพื่อปรับแต่งได้ ดังนี้

# Enable LoRA for the model and set the LoRA rank to 4.
model.backbone.enable_lora(rank=4)

หลังจากเปิดใช้ LoRA แล้ว คุณสามารถเริ่มกระบวนการปรับแต่งได้ การดำเนินการนี้จะใช้เวลาประมาณ 5 นาทีต่อแต่ละยุคใน Colab

import tensorflow as tf

# Create dataset with preprocessed text + labels.
map_fn = lambda xy: agile_classifier.encode_for_training(*xy)
x_train = list(map(map_fn, df_train[['comment', 'hateful']].values))
ds_train = tf.data.Dataset.from_tensor_slices(x_train).batch(2)

# Compile the model using the Adam optimizer and appropriate loss function.
model.compile(
    loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
    optimizer=keras.optimizers.Adam(learning_rate=0.0005),
    weighted_metrics=[keras.metrics.SparseCategoricalAccuracy()],
)

# Begin training.
model.fit(ds_train, epochs=4)

การฝึกอบรมในจำนวนรอบมากขึ้นจะทําให้แม่นยําขึ้น จนกว่าจะเกิดภาวะการเรียนรู้มากเกินไป

9. ตรวจสอบผลลัพธ์

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

text = 'you look really nice today'
scores = agile_classifier.predict_score(model, text)
dict(zip(agile_classifier.labels, scores))

{'Positive': 0.99899644, 'Negative': 0.0010035498}

10. การประเมินโมเดล

สุดท้าย คุณประเมินประสิทธิภาพของโมเดลโดยใช้เมตริกทั่วไป 2 รายการ ได้แก่ คะแนน F1 และ AUC-ROC คะแนน F1 จะบันทึกข้อผิดพลาดเชิงลบและข้อผิดพลาดเชิงบวกลวงโดยประเมินค่าเฉลี่ยฮาร์โมนิกของความแม่นยำและความอ่อนไหวที่เกณฑ์การจัดประเภทหนึ่งๆ ในทางกลับกัน AUC-ROC จะจับภาพการประนีประนอมระหว่างอัตราผลบวกจริงกับอัตราผลบวกลวงในเกณฑ์ต่างๆ และคำนวณพื้นที่ใต้เส้นโค้งนี้

from sklearn.metrics import f1_score, roc_auc_score

y_true = df_test['hateful'].values
# Compute the scores (aka probabilities) for each of the labels.
y_score = [agile_classifier.predict_score(model, x) for x in df_test['comment']]
# The label with highest score is considered the predicted class.
y_pred = np.argmax(y_score, axis=1)
# Extract the probability of a comment being considered hateful.
y_prob = [x[agile_classifier.labels.index('Negative')] for x in y_score]

# Compute F1 and AUC-ROC scores.
print(f'F1: {f1_score(y_true, y_pred):.2f}')
print(f'AUC-ROC: {roc_auc_score(y_true, y_prob):.2f}')

F1: 0.84
AUC-ROC: = 0.88

อีกวิธีที่น่าสนใจในการประเมินการคาดการณ์ของโมเดลคือเมทริกซ์ความสับสน ตารางความสับสนจะแสดงข้อผิดพลาดในการคาดการณ์ประเภทต่างๆ เป็นภาพ

from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay

cm = confusion_matrix(y_true, y_pred)
ConfusionMatrixDisplay(
    confusion_matrix=cm,
    display_labels=agile_classifier.labels,
).plot()

สุดท้าย คุณยังดูเส้นโค้ง ROC เพื่อทําความเข้าใจข้อผิดพลาดในการคาดการณ์ที่อาจเกิดขึ้นเมื่อใช้เกณฑ์การให้คะแนนที่แตกต่างกันได้ด้วย

from sklearn.metrics import RocCurveDisplay, roc_curve

fpr, tpr, _ = roc_curve(y_true, y_prob, pos_label=1)
RocCurveDisplay(fpr=fpr, tpr=tpr).plot()