Gemma ile Çevik Güvenlik Sınıflandırıcılarını Sergileme

1. Genel Bakış

Bu codelab'de, parametre verimli ayarlama (PET) kullanılarak özelleştirilmiş bir metin sınıflandırıcının nasıl oluşturulacağı gösterilmektedir. PET yöntemleri, modelin tamamını hassaslaştırmak yerine yalnızca az sayıda parametreyi günceller. Bu da modelin eğitilmesini nispeten kolay ve hızlı hale getirir. Ayrıca, modelin nispeten az eğitim verisi kullanarak yeni davranışlar öğrenmesini kolaylaştırır. Bu tekniklerin çeşitli güvenlik görevlerine nasıl uygulanabileceğini ve yalnızca birkaç yüz eğitim örneğiyle en son performansa nasıl ulaşılabileceğini gösteren Herkes İçin Çevik Metin Sınıflandırıcıları başlıklı makalede bu metodoloji ayrıntılı olarak açıklanmaktadır.

Bu codelab'de, daha hızlı ve daha verimli çalışabildiği için LoRA PET yöntemi ve daha küçük Gemma modeli (gemma_instruct_2b_en) kullanılır. Bu colab'da, verileri besleme, LLM için biçimlendirme, LoRA ağırlıklarını eğitme ve ardından sonuçları değerlendirme adımları ele alınmaktadır. Bu kod laboratuvarı, YouTube ve Reddit yorumlarından oluşturulan, nefret söylemini algılamaya yönelik herkese açık bir veri kümesi olan ETHOS veri kümesiyle çalışır. Yalnızca 200 örnekle (veri kümesinin 1/4'ü) eğitildiğinde F1: 0,80 ve ROC-AUC: 0,78 değerine ulaşır. Bu değer, şu anda puan tablosunda (bu makalenin yazıldığı tarih itibarıyla 15 Şubat 2024) raporlanan SOTA'nın biraz üzerindedir. 800 örneğin tamamıyla eğitildiğinde 83,74 F1 puanı ve 88,17 ROC-AUC puanı elde eder. gemma_instruct_7b_en gibi daha büyük modeller genellikle daha iyi performans gösterir ancak eğitim ve yürütme maliyetleri de daha yüksektir.

Tetikleyici Uyarısı: Bu kod laboratuvarında nefret söylemini algılamak için bir güvenlik sınıflandırıcısı geliştirildiğinden, örnekler ve sonuçların değerlendirilmesi bazı korkunç ifadeler içerir.

2. Yükleme ve Kurulum

Bu kod laboratuvarının çalışması için keras (3) ve keras-nlp (0.8.0) sürümlerinin son sürümüne ve temel modeli indirmek için bir Kaggle hesabına ihtiyacınız vardır.

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

Kaggle'e giriş yapmak için kaggle.json kimlik bilgisi dosyanızı ~/.kaggle/kaggle.json adresinde saklayabilir veya Colab ortamında aşağıdakileri çalıştırabilirsiniz:

import kagglehub

kagglehub.login()

Bu kod laboratuvarı, Keras arka ucu olarak TensorFlow kullanılarak test edilmiştir ancak TensorFlow, Pytorch veya JAX'i kullanabilirsiniz:

import os

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

3. ETHOS veri kümesini yükleme

Bu bölümde, sınıflandırıcımızı eğiteceğiniz veri kümesini yükleyip eğitim ve test kümesi olarak ön işleme tabi tutacaksınız. Sosyal medyada nefret söylemini tespit etmek için toplanan popüler ETHOS araştırma veri kümesini kullanacaksınız. Veri kümesinin nasıl toplandığı hakkında daha fazla bilgiyi ETHOS: an Online Hate Speech Detection Dataset (ETHOS: İnternette Nefret Söylemi Algılama Veri Kümesi) makalesinde bulabilirsiniz.

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

Aşağıdakine benzer bir şey görürsünüz:

	etiket	yorum
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. Modeli indirip örneklendirme

Dokümanda açıklandığı gibi, Gemma modelini birçok şekilde kolayca kullanabilirsiniz. Keras'ta yapmanız gerekenler:

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

Modelin çalıştığını test etmek için metin oluşturabilirsiniz:

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

5. Metin Ön İşleme ve Ayırıcı Jetonları

Modelin amacımızı daha iyi anlamasına yardımcı olmak için metni ön işleme alabilir ve ayırıcı jetonları kullanabilirsiniz. Bu sayede modelin beklenen biçime uymayan metin oluşturma olasılığı azalır. Örneğin, şu gibi bir istem yazarak modelden bir duygu sınıflandırması isteğinde bulunabilirsiniz:

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

Text: you look very nice today
Classification:

Bu durumda model, aradığınızı döndürebilir veya döndürmeyebilir. Örneğin, metin satır sonu karakterleri içeriyorsa model performansını olumsuz yönde etkileyebilir. Daha sağlam bir yaklaşım, ayırıcı jetonları kullanmaktır. İstem şu şekilde olur:

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

Bu, metni ön işleme tabi tutan bir işlev kullanılarak soyutlanabilir:

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

Artık işlevi daha önce olduğu gibi aynı istemi ve metni kullanarak çalıştırırsanız aynı çıkışı alırsınız:

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)

Bu komutun çıktısı şu şekilde olur:

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. Çıkış işleme sonrası

Modelin çıkışları, çeşitli olasılıklara sahip jetonlardır. Normalde metin oluşturmak için en olası birkaç jeton arasından seçim yapar ve cümleler, paragraflar hatta tam dokümanlar oluşturursunuz. Ancak sınıflandırma amacıyla asıl önemli olan, modelin Positive değerinin Negative değerinden daha olası olduğuna veya bunun tam tersine inanıp inanmadığıdır.

Daha önce örneklendirdiğiniz modelin çıkışını, bir sonraki jetonun Positive veya Negative olma olasılıklarını bağımsız olarak işlemek için aşağıdaki şekilde kullanabilirsiniz:

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()))

Bu işlevi daha önce oluşturduğunuz bir istemle çalıştırarak test edebilirsiniz:

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

Bu komut, aşağıdakine benzer bir çıkış verir:

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

7. Tümünü sınıflandırıcı olarak sarmalama

Kullanım kolaylığı için, yeni oluşturduğunuz tüm işlevleri predict() ve predict_score() gibi kullanımı kolay ve tanıdık işlevlerle tek bir sklearn benzeri sınıflandırıcıya sarmalayabilirsiniz.

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. Modeli hassas ayarlama

LoRA, Düşük Sıralı Uyum anlamına gelir. Büyük dil modellerini verimli bir şekilde hassaslaştırmak için kullanılabilen bir hassas ayar tekniğidir. Bu konu hakkında daha fazla bilgiyi LoRA: Low-Rank Adaptation of Large Language Models (LoRA: Büyük Dil Modellerinin Düşük Sıralı Uyarlaması) makalesinde bulabilirsiniz.

Gemma'nın Keras uygulaması, hassas ayarlama için kullanabileceğiniz bir enable_lora() yöntemi sağlar:

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

LoRA'yı etkinleştirdikten sonra hassas ayar sürecine başlayabilirsiniz. Bu işlem Colab'da her epoch için yaklaşık 5 dakika sürer:

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)

Aşırı uyum sağlanana kadar daha fazla dönem için eğitim, daha yüksek doğrulukla sonuçlanır.

9. Sonuçları İnceleme

Artık yeni eğittiğiniz çevik sınıflandırıcının çıktısını inceleyebilirsiniz. Bu kod, bir metin parçası verildiğinde tahmin edilen sınıf puanını döndürür:

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. Model Değerlendirmesi

Son olarak, F1 puanı ve AUC-ROC olmak üzere iki yaygın metriği kullanarak modelimizin performansını değerlendirirsiniz. F1 puanı, belirli bir sınıflandırma eşiğinde hassasiyet ve geri çağırmanın harmonik ortalamasını değerlendirerek yanlış negatif ve yanlış pozitif hataları yakalar. Öte yandan AUC-ROC, çeşitli eşiklerde gerçek pozitif oranı ile yanlış pozitif oranı arasındaki dengeyi yakalar ve bu eğrinin altında kalan alanı hesaplar.

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

Model tahminlerini değerlendirmenin ilginç bir başka yolu da karışıklık matrisleridir. Karıştırma matrisi, farklı tahmin hatalarını görsel olarak gösterir.

from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay

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

Son olarak, farklı puanlama eşikleri kullanırken olası tahmin hatalarını anlamak için ROC eğrisine de bakabilirsiniz.

from sklearn.metrics import RocCurveDisplay, roc_curve

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