Siapkan lingkungan Anda Kirim permintaan inferensi sampel Mengatur FMEval Jalankan evaluasi model Anda Lihat hasil analisis Anda

Evaluasi JumpStart model untuk stereotip cepat

Anda dapat menggunakan ModelRunner pembungkus tingkat tinggi untuk mengevaluasi SageMaker JumpStart model Amazon untuk stereotip cepat. Algoritma stereotip cepat mengukur probabilitas bias pengkodean model Anda dalam responsnya. Bias ini termasuk untuk ras, jenis kelamin, orientasi seksual, agama, usia, kebangsaan, kecacatan, penampilan fisik, dan status sosial ekonomi.

Tutorial ini menunjukkan cara memuat model Falcon 7-B dari Technology Innovation Institute, tersedia di JumpStart, dan meminta model ini untuk menghasilkan tanggapan terhadap petunjuk. Kemudian, tutorial ini menunjukkan cara mengevaluasi respons untuk stereotip cepat terhadap kumpulan data tantangan sumber terbuka Crows-pair bawaan.

Bagian dari tutorial ini menunjukkan bagaimana melakukan hal berikut:

Siapkan lingkungan Anda.
Jalankan evaluasi model Anda.
Lihat hasil analisis Anda.

Siapkan lingkungan Anda

Prasyarat

Gunakan basis Python 3.10 lingkungan kernel dan instans ml.g4dn.2xlarge Amazon Elastic Compute Cloud EC2 (Amazon) sebelum memulai tutorial ini.

Untuk informasi selengkapnya tentang jenis instans dan kasus penggunaan yang direkomendasikan, lihatJenis instans tersedia untuk digunakan dengan Studio Classic.

Instal pustaka yang diperlukan

Instal SageMaker AI,fmeval, dan pustaka lain yang diperlukan dalam kode Anda sebagai berikut:


!pip3 install sagemaker
!pip3 install -U pyarrow
!pip3 install -U accelerate
!pip3 install "ipywidgets>=8"
!pip3 install jsonlines
!pip install fmeval
!pip3 install boto3==1.28.65
import sagemaker

Unduh JSON Lines kumpulan data sampel crows-pairs_sample.jsonl, ke direktori kerja Anda saat ini.

Periksa apakah lingkungan Anda berisi file input sampel menggunakan kode berikut:


import glob

# Check for fmeval wheel and built-in dataset
if not glob.glob("crows-pairs_sample.jsonl"):
print("ERROR - please make sure file exists: crows-pairs_sample.jsonl")

Tentukan JumpStart model sebagai berikut:


from sagemaker.jumpstart.model import JumpStartModel

model_id, model_version, = (
"huggingface-llm-falcon-7b-instruct-bf16",
"*",
)

Terapkan JumpStart model dan buat titik akhir sebagai berikut:


my_model = JumpStartModel(model_id=model_id)
predictor = my_model.deploy()
endpoint_name = predictor.endpoint_name

Tentukan prompt dan format permintaan model, atau payload, sebagai berikut:
```
prompt = "London is the capital of"
payload = {
"inputs": prompt,
"parameters": {
    "do_sample": True,
    "top_p": 0.9,
    "temperature": 0.8,
    "max_new_tokens": 1024,
    "decoder_input_details" : True,
    "details" : True
},
}
```
Dalam contoh kode sebelumnya, parameter berikut disertakan dalam permintaan model:
- do_sample— Menginstruksikan model untuk mengambil sampel dari output model mentah (sebelum normalisasi) selama inferensi model untuk memperkenalkan keragaman dan kreativitas ke dalam respons model. Default ke False. Jika Anda mengatur do_sample keTrue, maka Anda harus menentukan nilai untuk salah satu parameter berikut:temperature,top_k,top_p, atautypical_p.
- top_p— Mengontrol keacakan dengan membatasi set token untuk dipertimbangkan saat membuat token berikutnya. Nilai yang lebih tinggi dari top_p memungkinkan untuk satu set yang berisi kosakata yang lebih luas. Nilai yang lebih rendah membatasi kumpulan token ke kata-kata yang lebih mungkin. Rentang untuk top_p lebih besar dari 0 dan kurang dari1.
- temperature— Mengontrol keacakan teks yang dihasilkan. Nilai yang lebih tinggi dari temperature menginstruksikan model untuk menghasilkan respons yang lebih acak dan beragam. Nilai yang lebih rendah menghasilkan respons yang lebih dapat diprediksi. Nilai untuk temperature harus positif.
- max_new_tokens— Membatasi panjang respons dengan membatasi jumlah token yang dikembalikan oleh model Anda. Default ke 20.
- decoder_input_details— Mengembalikan informasi tentang probabilitas log yang ditetapkan oleh model untuk setiap token potensial berikutnya dan token yang sesuai. IDs Jika decoder_input_details diatur keTrue, Anda juga harus mengatur details untuk True menerima detail yang diminta. Default ke False.
Untuk informasi selengkapnya tentang parameter untuk Hugging Face model ini, lihat types.py.

Kirim permintaan inferensi sampel

Untuk menguji model Anda, kirim permintaan sampel ke model Anda dan cetak respons model sebagai berikut:


response = predictor.predict(payload)
print(response[0]["generated_text"])

Dalam contoh kode sebelumnya, jika model Anda memberikan respons[{"response": "this is the output"}], maka print pernyataan akan kembalithis is the output.

Mengatur FMEval

Muat pustaka yang diperlukan untuk dijalankan FMEval sebagai berikut:


import fmeval
from fmeval.data_loaders.data_config import DataConfig
from fmeval.model_runners.sm_jumpstart_model_runner import JumpStartModelRunner
from fmeval.constants import MIME_TYPE_JSONLINES
from fmeval.eval_algorithms.prompt_stereotyping import PromptStereotyping, PROMPT_STEREOTYPING
from fmeval.eval_algorithms import EvalAlgorithm

Siapkan konfigurasi data untuk dataset input Anda.

Jika Anda tidak menggunakan kumpulan data bawaan, konfigurasi data Anda harus mengidentifikasi kolom yang berisi lebih banyak bias. sent_more_input_location Anda juga harus mengidentifikasi kolom yang mengandung lebih sedikit bias disent_less_input_location. Jika Anda menggunakan kumpulan data bawaan dari JumpStart, parameter ini diteruskan ke metadata model FMEval secara otomatis.

Tentukan sent_more_input_location dan sent_less_input_location kolom untuk tugas stereotip cepat, nama, pengidentifikasi sumber daya seragam (URI), dan MIME jenis.
```
config = DataConfig(
dataset_name="crows-pairs_sample",
dataset_uri="crows-pairs_sample.jsonl",
dataset_mime_type=MIME_TYPE_JSONLINES,
sent_more_input_location="sent_more",
sent_less_input_location="sent_less",
category_location="bias_type",
)
```
Untuk informasi selengkapnya tentang informasi kolom yang diperlukan tugas lain, lihat bagian Menggunakan kumpulan data input kustom diMenggunakan dataset masukan kustom.
Siapkan kustom ModelRunner seperti yang ditunjukkan pada contoh kode berikut:
```
js_model_runner = JumpStartModelRunner(
endpoint_name=endpoint_name,
model_id=model_id,
model_version=model_version,
output='[0].generated_text',
log_probability='[0].details.prefill[*].logprob',
content_template='{"inputs": $prompt, "parameters":
{"do_sample": true, "top_p": 0.9, "temperature": 0.8, "max_new_tokens": 1024,
"decoder_input_details": true,"details": true}}',
)
```
Contoh kode sebelumnya menentukan yang berikut:
- endpoint_name— Nama endpoint yang Anda buat di langkah Install required library sebelumnya.
- model_id— Id yang digunakan untuk menentukan model Anda. Parameter ini ditentukan ketika JumpStart model didefinisikan.
- model_version— Versi model Anda yang digunakan untuk menentukan model Anda. Parameter ini ditentukan ketika JumpStart model didefinisikan.
- output— Menangkap output dari model Falcon 7b, yang mengembalikan responsnya dalam kunci. generated_text Jika model Anda memberikan respons[{"generated_text": "this is the output"}], maka [0].generated_text kembalithis is the output.
- log_probability— Menangkap probabilitas log yang dikembalikan oleh JumpStart model ini.
- content_template— Menentukan bagaimana model Anda berinteraksi dengan permintaan. Contoh template konfigurasi dirinci semata-mata untuk menjelaskan contoh sebelumnya, dan itu tidak diperlukan. Parameter dalam template konten adalah parameter yang sama yang dideklarasikan untukpayload. Untuk informasi selengkapnya tentang parameter untuk Hugging Face model ini, lihat types.py.

Konfigurasikan laporan evaluasi Anda dan simpan ke direktori seperti yang ditunjukkan pada contoh kode berikut:


import os
eval_dir = "results-eval-prompt-stereotyping"
curr_dir = os.getcwd()
eval_results_path = os.path.join(curr_dir, eval_dir) + "/"
os.environ["EVAL_RESULTS_PATH"] = eval_results_path
if os.path.exists(eval_results_path):
print(f"Directory '{eval_results_path}' exists.")
else:
os.mkdir(eval_results_path)

Siapkan faktor paralelisasi sebagai berikut:
```
os.environ["PARALLELIZATION_FACTOR"] = "1"
```
A PARALLELIZATION_FACTOR adalah pengganda untuk jumlah batch bersamaan yang dikirim ke instance komputasi Anda. Jika perangkat keras Anda memungkinkan paralelisasi, Anda dapat mengatur nomor ini untuk melipatgandakan jumlah pemanggilan untuk pekerjaan evaluasi Anda. Misalnya, jika Anda memiliki 100 pemanggilan, dan PARALLELIZATION_FACTOR disetel ke2, maka pekerjaan Anda akan menjalankan 200 pemanggilan. Anda dapat meningkatkan PARALLELIZATION_FACTOR hingga10, atau menghapus variabel seluruhnya. Untuk membaca blog tentang cara penggunaan AWS Lambda, PARALLELIZATION_FACTOR lihat Kontrol penskalaan AWS Lambda Baru untuk sumber peristiwa Kinesis dan DynamoDB.

Jalankan evaluasi model Anda

Tentukan algoritma evaluasi Anda. Contoh berikut menunjukkan bagaimana mendefinisikan PromptStereotyping algoritma:
```
eval_algo = PromptStereotyping()
```
Untuk contoh algoritme yang menghitung metrik untuk tugas evaluasi lainnya, lihat Mengevaluasi model Anda. Gunakan fmeval pustaka untuk menjalankan evaluasi otomatis
Jalankan algoritma evaluasi Anda. Contoh kode berikut menggunakan model dan konfigurasi data yang telah ditentukan sebelumnya, dan prompt_template yang digunakan feature untuk meneruskan prompt Anda ke model sebagai berikut:
```
eval_output = eval_algo.evaluate(model=js_model_runner, dataset_config=config,
prompt_template="$feature", save=True)
```
Output model Anda mungkin berbeda dari output sampel sebelumnya.

Lihat hasil analisis Anda

Parse laporan evaluasi dari eval_output objek yang dikembalikan oleh algoritma evaluasi sebagai berikut:
```
import json
print(json.dumps(eval_output, default=vars, indent=4))
```
Perintah sebelumnya mengembalikan output berikut (diringkas untuk singkatnya):
```
[
{
    "eval_name": "prompt_stereotyping",
    "dataset_name": "crows-pairs_sample",
    "dataset_scores": [
        {
            "name": "prompt_stereotyping",
            "value": 0.6666666666666666
        }
    ],
    "prompt_template": "$feature",
    "category_scores": [
        {
            "name": "disability",
            "scores": [
                {
                    "name": "prompt_stereotyping",
                    "value": 0.5
                }
            ]
        },
        ...
    ],
    "output_path": "/home/sagemaker-user/results-eval-prompt-stereotyping/prompt_stereotyping_crows-pairs_sample.jsonl",
    "error": null
}
]
```
Output contoh sebelumnya menampilkan skor keseluruhan untuk dataset berikut"name": prompt_stereotyping. Skor ini adalah perbedaan yang dinormalisasi dalam probabilitas log antara respons model yang memberikan bias lebih banyak versus lebih sedikit. Jika skornya lebih besar dari0.5, ini berarti respons model Anda lebih cenderung mengembalikan respons yang mengandung lebih banyak bias. Jika skornya kurang dari0.5, model Anda lebih cenderung mengembalikan respons yang mengandung lebih sedikit bias. Jika skornya0.5, respons model tidak mengandung bias yang diukur dengan dataset input. Anda akan menggunakan output_path untuk membuat Pandas DataFrame di langkah berikut.

Impor hasil Anda dan baca ke dalamDataFrame, dan lampirkan skor stereotip prompt ke input model, output model, dan output target sebagai berikut:


import pandas as pd
data = []
with open(os.path.join(eval_results_path,
"prompt_stereotyping_crows-pairs_sample.jsonl"), "r") as file:
for line in file:
data.append(json.loads(line))
df = pd.DataFrame(data)
df['eval_algo'] = df['scores'].apply(lambda x: x[0]['name'])
df['eval_score'] = df['scores'].apply(lambda x: x[0]['value'])
df

Untuk buku catatan yang berisi contoh kode yang diberikan di bagian ini, lihat jumpstart-falcon-stereotyping.ipnyb.

Awas Javascript dinonaktifkan atau tidak tersedia di browser Anda.

Untuk menggunakan Dokumentasi AWS, Javascript harus diaktifkan. Lihat halaman Bantuan browser Anda untuk petunjuk.

Konvensi Dokumen

Tutorial notebook evaluasi model

Evaluasi model Amazon Bedrock untuk akurasi ringkasan teks