Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# 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](https://huggingface.co/tiiuae/falcon-7b) dari [Technology Innovation Institute](https://www.tii.ae/), 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 [CrowS-Pairs](https://github.com/nyu-mll/crows-pairs)open source 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 lingkungan kernel dasar Python 3.10 dan instans `ml.g4dn.2xlarge` Amazon Elastic Compute Cloud (Amazon EC2) sebelum memulai tutorial ini.
Untuk informasi selengkapnya tentang jenis instans dan kasus penggunaan yang direkomendasikan, lihat[Jenis Instance Tersedia untuk Digunakan Dengan Notebook Amazon SageMaker Studio Classic](notebooks-available-instance-types.md).
**Instal pustaka yang diperlukan**
1. 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
```
1. Unduh `JSON Lines` kumpulan data sampel [crows-pairs\_sample.jsonl](https://github.com/aws/fmeval/blob/main/examples/crows-pairs_sample.jsonl), ke direktori kerja Anda saat ini.
1. 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")
```
1. Tentukan JumpStart model sebagai berikut:
```
from sagemaker.jumpstart.model import JumpStartModel
model_id, model_version, = (
"huggingface-llm-falcon-7b-instruct-bf16",
"*",
)
```
1. 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
```
1. 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` ke`True`, maka Anda harus menentukan nilai untuk salah satu parameter berikut:`temperature`,`top_k`,`top_p`, atau`typical_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 dari`1`.
+ `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 ID token yang sesuai. Jika `decoder_input_details` diatur ke`True`, 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](https://github.com/huggingface/text-generation-inference/blob/v0.9.3/clients/python/text_generation/types.py#L8).
## 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 kembali`this is the output`.
## Siapkan FMEval
1. Muat pustaka yang diperlukan untuk menjalankan 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
```
1. 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 di`sent_less_input_location`. Jika Anda menggunakan dataset bawaan dari JumpStart, parameter ini diteruskan ke FMEval secara otomatis melalui metadata model.
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** di[Menggunakan dataset masukan kustom](clarify-foundation-model-evaluate-auto-lib-custom.md#clarify-foundation-model-evaluate-auto-lib-custom-input).
1. 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](https://huggingface.co/tiiuae/falcon-7b), yang mengembalikan responsnya dalam kunci. `generated_text` Jika model Anda memberikan respons`[{"generated_text": "this is the output"}]`, maka `[0].generated_text` kembali`this 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 untuk`payload`. Untuk informasi selengkapnya tentang parameter untuk `Hugging Face` model ini, lihat [types.py](https://github.com/huggingface/text-generation-inference/blob/v0.9.3/clients/python/text_generation/types.py#L8).
1. 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)
```
1. 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 ke`2`, maka pekerjaan Anda akan menjalankan `200` pemanggilan. Anda dapat meningkatkan `PARALLELIZATION_FACTOR` hingga`10`, atau menghapus variabel seluruhnya. Untuk membaca blog tentang cara penggunaan AWS Lambda, `PARALLELIZATION_FACTOR` lihat [Kontrol penskalaan AWS Lambda Baru untuk sumber peristiwa Kinesis](https://aws.amazon.com/blogs/compute/new-aws-lambda-scaling-controls-for-kinesis-and-dynamodb-event-sources/) dan DynamoDB.
## Jalankan evaluasi model Anda
1. 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 pustaka `fmeval` untuk menjalankan evaluasi otomatis](clarify-foundation-model-evaluate-auto-lib.md)
1. 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
1. 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 dari`0.5`, ini berarti respons model Anda lebih cenderung mengembalikan respons yang mengandung lebih banyak bias. Jika skornya kurang dari`0.5`, model Anda lebih cenderung mengembalikan respons yang mengandung lebih sedikit bias. Jika skornya`0.5`, respons model tidak mengandung bias yang diukur dengan dataset input. Anda akan menggunakan `output_path` untuk membuat `Pandas` `DataFrame` di langkah berikut.
1. Impor hasil Anda dan baca ke dalam`DataFrame`, 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](https://github.com/aws/fmeval/blob/main/examples/jumpstart-falcon-stereotyping.ipynb).