Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Sesuaikan alur kerja Anda menggunakan pustaka `fmeval`
Anda dapat menyesuaikan evaluasi model Anda untuk memungkinkan model yang bukan model JumpStart atau Amazon Bedrock atau menggunakan alur kerja khusus untuk evaluasi. Jika Anda menggunakan model Anda sendiri, Anda harus membuat kustom`ModelRunner`. Jika Anda menggunakan dataset Anda sendiri untuk evaluasi, Anda harus mengkonfigurasi `DataConfig` objek. Bagian berikut menunjukkan cara memformat dataset input Anda, menyesuaikan `DataConfig` objek untuk menggunakan dataset kustom Anda, dan membuat kustom. `ModelRunner`
## Menggunakan dataset masukan kustom
Jika Anda ingin menggunakan kumpulan data Anda sendiri untuk mengevaluasi model Anda, Anda harus menggunakan `DataConfig` objek untuk menentukan `dataset_name` dan kumpulan data yang ingin Anda evaluasi. `dataset_uri` Jika Anda menggunakan dataset bawaan, `DataConfig` objek sudah dikonfigurasi sebagai default untuk algoritma evaluasi.
Anda dapat menggunakan satu kumpulan data khusus setiap kali Anda menggunakan `evaluate` fungsi tersebut. Anda dapat memanggil `evaluate` beberapa kali untuk menggunakan sejumlah kumpulan data yang Anda inginkan.
Konfigurasikan kumpulan data khusus dengan permintaan model Anda yang ditentukan di kolom pertanyaan, dan jawaban target yang ditentukan dalam jawaban kolom, sebagai berikut:
```
from fmeval.data_loaders.data_config import DataConfig
from fmeval.constants import MIME_TYPE_JSONLINES
config = DataConfig(
dataset_name="tiny_dataset",
dataset_uri="tiny_dataset.jsonl",
dataset_mime_type=MIME_TYPE_JSONLINES,
model_input_location="question",
target_output_location="answer",
)
```
`DataConfig`Kelas berisi parameter berikut:
+ `dataset_name`— Nama dataset yang ingin Anda gunakan untuk mengevaluasi LLM Anda.
`dataset_uri`— Jalur lokal atau pengidentifikasi sumber daya seragam (URI) ke lokasi S3 dari kumpulan data Anda.
+ `dataset_mime_type`— Format data input yang ingin Anda gunakan untuk mengevaluasi LLM Anda. FMEval Perpustakaan dapat mendukung keduanya `MIME_TYPE_JSON` dan`MIME_TYPE_JSONLINES`.
+ `model_input_location`— (Opsional) Nama kolom dalam dataset Anda yang berisi input model atau prompt yang ingin Anda evaluasi.
Gunakan `model_input_location` yang menentukan nama kolom Anda. Kolom harus berisi nilai-nilai berikut yang sesuai dengan tugas-tugas terkait berikut:
+ Untuk evaluasi **generasi terbuka**, **toksisitas**, dan **akurasi**, tentukan kolom yang berisi **prompt** yang harus ditanggapi oleh model Anda.
+ Untuk tugas **menjawab pertanyaan**, tentukan kolom yang berisi **pertanyaan** yang harus direspon oleh model Anda.
+ Untuk **tugas meringkas teks**, tentukan nama kolom yang berisi **teks** yang ingin diringkas oleh model Anda.
+ Untuk **tugas klasifikasi**, tentukan nama kolom yang berisi **teks** yang ingin diklasifikasikan oleh model Anda.
+ Untuk evaluasi **pengetahuan faktual**, tentukan nama kolom yang berisi **pertanyaan** yang Anda inginkan model untuk memprediksi jawabannya.
+ Untuk evaluasi **ketahanan semantik**, tentukan nama kolom yang berisi **input** yang Anda inginkan untuk diganggu oleh model Anda.
+ Untuk evaluasi **stereotip yang cepat**, gunakan `sent_more_input_location` dan ` sent_less_input_location` bukan`model_input_location`, seperti yang ditunjukkan pada parameter berikut.
+ `model_output_location`— (Opsional) Nama kolom dalam dataset Anda yang berisi output prediksi yang ingin Anda bandingkan dengan output referensi yang terkandung di `target_output_location` dalamnya. Jika Anda memberikan`model_output_location`, maka FMEval tidak akan mengirim permintaan ke model Anda untuk inferensi. Sebaliknya, ia menggunakan output yang terkandung dalam kolom yang ditentukan untuk mengevaluasi model Anda.
+ `target_output_location`— Nama kolom dalam dataset referensi yang berisi nilai sebenarnya untuk dibandingkan dengan nilai prediksi yang terkandung di `model_output_location` dalamnya. Diperlukan hanya untuk pengetahuan faktual, akurasi, dan ketahanan semantik. Untuk pengetahuan faktual, setiap baris di kolom ini harus berisi semua kemungkinan jawaban yang dipisahkan oleh pembatas. Misalnya, jika jawaban untuk pertanyaan adalah [“UK”, “Inggris”], maka kolom harus berisi “Inggris Inggris”. Prediksi model benar jika berisi salah satu jawaban yang dipisahkan oleh pembatas.
+ `category_location`— Nama kolom yang berisi nama kategori. Jika Anda memberikan nilai untuk`category_location`, maka skor dikumpulkan dan dilaporkan untuk setiap kategori.
+ `sent_more_input_location`— Nama kolom yang berisi prompt dengan lebih banyak bias. Diperlukan hanya untuk stereotip cepat. Hindari bias bawah sadar. Untuk contoh bias, lihat kumpulan data [Crows-pairs](https://paperswithcode.com/dataset/crows-pairs).
+ `sent_less_input_location`— Nama kolom yang berisi prompt dengan bias yang lebih sedikit. Diperlukan hanya untuk stereotip cepat. Hindari bias bawah sadar. Untuk contoh bias, lihat kumpulan data [Crows-pairs](https://paperswithcode.com/dataset/crows-pairs).
+ `sent_more_output_location`— (Opsional) Nama kolom yang berisi probabilitas prediksi bahwa respons yang dihasilkan model Anda akan mengandung lebih banyak bias. Parameter ini hanya digunakan dalam tugas stereotip cepat.
+ `sent_less_output_location`— (Opsional) Nama kolom yang berisi probabilitas prediksi bahwa respons yang dihasilkan model Anda akan mengandung lebih sedikit bias. Parameter ini hanya digunakan dalam tugas stereotip cepat.
Jika Anda ingin menambahkan atribut baru yang sesuai dengan kolom dataset ke `DataConfig` kelas, Anda harus menambahkan `suffix _location` ke akhir nama atribut.
## Gunakan kustom `ModelRunner`
Untuk mengevaluasi model kustom, gunakan kelas data dasar untuk mengonfigurasi model Anda dan membuat kustom`ModelRunner`. Kemudian, Anda dapat menggunakan ini `ModelRunner` untuk mengevaluasi model bahasa apa pun. Gunakan langkah-langkah berikut untuk menentukan konfigurasi model, membuat kustom`ModelRunner`, dan mengujinya.
`ModelRunner`Antarmuka memiliki satu metode abstrak sebagai berikut:
```
def predict(self, prompt: str) → Tuple[Optional[str], Optional[float]]
```
Metode ini mengambil prompt sebagai input string, dan mengembalikan Tuple yang berisi respons teks model dan probabilitas log masukan. Setiap orang `ModelRunner` harus menerapkan `predict` metode.
**Buat kustom `ModelRunner`**
1. Tentukan konfigurasi model.
Contoh kode berikut menunjukkan cara menerapkan `dataclass` dekorator ke `HFModelConfig` kelas khusus sehingga Anda dapat menentukan konfigurasi model untuk **Hugging Face**model:
```
from dataclasses import dataclass
@dataclass
class HFModelConfig:
model_name: str
max_new_tokens: int
seed: int = 0
remove_prompt_from_generated_text: bool = True
```
Dalam contoh kode sebelumnya, berikut ini berlaku:
+ Parameter `max_new_tokens` ini digunakan untuk membatasi panjang respons dengan membatasi jumlah token yang dikembalikan oleh LLM. Jenis model diatur dengan melewatkan nilai `model_name` ketika kelas dipakai. Dalam contoh ini, nama model diatur ke`gpt2`, seperti yang ditunjukkan pada akhir bagian ini. Parameter `max_new_tokens` adalah salah satu opsi untuk mengonfigurasi strategi pembuatan teks menggunakan konfigurasi `gpt2` model untuk model GPT OpenAI yang telah dilatih sebelumnya. Lihat [AutoConfig](https://huggingface.co/transformers/v3.5.1/model_doc/auto.html)untuk jenis model lainnya.
+ Jika parameter `remove_prompt_from_generated_text` disetel ke`True`, maka respons yang dihasilkan tidak akan berisi prompt asal yang dikirim dalam permintaan.
Untuk parameter pembuatan teks lainnya, lihat [Hugging Facedokumentasi untuk GenerationConfig](https://huggingface.co/docs/transformers/v4.34.1/en/main_classes/text_generation#transformers.GenerationConfig).
1. Buat kustom `ModelRunner` dan terapkan metode prediksi. Contoh kode berikut menunjukkan cara membuat kustom `ModelRunner` untuk Hugging Face model menggunakan `HFModelConfig` kelas yang dibuat dalam contoh kode sebelumnya.
```
from typing import Tuple, Optional
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from fmeval.model_runners.model_runner import ModelRunner
class HuggingFaceCausalLLMModelRunner(ModelRunner):
def __init__(self, model_config: HFModelConfig):
self.config = model_config
self.model = AutoModelForCausalLM.from_pretrained(self.config.model_name)
self.tokenizer = AutoTokenizer.from_pretrained(self.config.model_name)
def predict(self, prompt: str) -> Tuple[Optional[str], Optional[float]]:
input_ids = self.tokenizer(prompt, return_tensors="pt").to(self.model.device)
generations = self.model.generate(
**input_ids,
max_new_tokens=self.config.max_new_tokens,
pad_token_id=self.tokenizer.eos_token_id,
)
generation_contains_input = (
input_ids["input_ids"][0] == generations[0][: input_ids["input_ids"].shape[1]]
).all()
if self.config.remove_prompt_from_generated_text and not generation_contains_input:
warnings.warn(
"Your model does not return the prompt as part of its generations. "
"`remove_prompt_from_generated_text` does nothing."
)
if self.config.remove_prompt_from_generated_text and generation_contains_input:
output = self.tokenizer.batch_decode(generations[:, input_ids["input_ids"].shape[1] :])[0]
else:
output = self.tokenizer.batch_decode(generations, skip_special_tokens=True)[0]
with torch.inference_mode():
input_ids = self.tokenizer(self.tokenizer.bos_token + prompt, return_tensors="pt")["input_ids"]
model_output = self.model(input_ids, labels=input_ids)
probability = -model_output[0].item()
return output, probability
```
Kode sebelumnya menggunakan `HuggingFaceCausalLLMModelRunner` kelas kustom yang mewarisi properti dari FMEval `ModelRunner` kelas. Kelas kustom berisi konstruktor dan definisi untuk fungsi prediksi, yang mengembalikan a`Tuple`.
Untuk `ModelRunner` contoh lainnya, lihat bagian [model\_runner](https://github.com/aws/fmeval/tree/main/src/fmeval/model_runners) perpustakaan. `fmeval`
`HuggingFaceCausalLLMModelRunner`Konstruktor berisi definisi berikut:
+ Konfigurasi diatur ke`HFModelConfig`, didefinisikan di awal bagian ini.
+ Model diatur ke model pra-terlatih dari Hugging Face [Auto Class](https://huggingface.co/transformers/v3.5.1/model_doc/auto.html) yang ditentukan menggunakan parameter model\_name pada instantiation.
+ Tokenizer diatur ke kelas dari [pustaka Hugging Face tokenizer](https://huggingface.co/docs/transformers/model_doc/auto#transformers.AutoTokenizer) yang cocok dengan model pra-terlatih yang ditentukan oleh. `model_name`
`predict`Metode di `HuggingFaceCausalLLMModelRunner` kelas menggunakan definisi berikut:
+ `input_ids`— Variabel yang berisi masukan untuk model Anda. Model menghasilkan input sebagai berikut.
+ A `tokenizer` Mengonversi permintaan yang terkandung `prompt` dalam pengenal token ()IDs. Token ini IDs, yang merupakan nilai numerik yang mewakili token tertentu (kata, sub-kata atau karakter), dapat digunakan langsung oleh model Anda sebagai input. Token IDs dikembalikan sebagai objek PyTorch tensor, seperti yang ditentukan oleh`return_tensors="pt"`. Untuk tipe tipe tensor kembali lainnya, lihat Hugging Face dokumentasi untuk [apply\_chat\_template](https://huggingface.co/docs/transformers/main_classes/tokenizer#transformers.PreTrainedTokenizer.apply_chat_template).
+ Token IDs dikirim ke perangkat tempat model berada sehingga dapat digunakan oleh model.
+ `generations`— Variabel yang berisi respons yang dihasilkan oleh LLM Anda. Fungsi generate model menggunakan input berikut untuk menghasilkan respons:
+ `input_ids`Dari langkah sebelumnya.
+ Parameter `max_new_tokens` yang ditentukan dalam`HFModelConfig`.
+ A `pad_token_id` menambahkan token akhir kalimat (eos) ke respons. Untuk token lain yang dapat Anda gunakan, lihat Hugging Face dokumentasi untuk [PreTrainedTokenizer](https://huggingface.co/docs/transformers/main_classes/tokenizer#transformers.PreTrainedTokenizer).
+ `generation_contains_input`- Variabel boolean yang kembali `True` ketika respons yang dihasilkan menyertakan prompt input dalam responsnya, dan `False` sebaliknya. Nilai pengembalian dihitung menggunakan perbandingan elemen antara yang berikut ini.
+ Semua token IDs dalam prompt input yang terkandung di dalamnya`input_ids["input_ids"][0]`.
+ Awal dari konten yang dihasilkan yang terkandung di dalamnya`generations[0][: input_ids["input_ids"].shape[1]]`.
`predict`Metode ini mengembalikan peringatan jika Anda mengarahkan LLM ke `remove_prompt_from_generated_text` dalam konfigurasi Anda tetapi respons yang dihasilkan tidak berisi prompt input.
Output dari `predict` metode ini berisi string yang dikembalikan oleh `batch_decode` metode, yang mengubah token yang IDs dikembalikan dalam respons menjadi teks yang dapat dibaca manusia. Jika Anda menentukan `remove_prompt_from_generated_text` sebagai`True`, maka prompt input dihapus dari teks yang dihasilkan. Jika Anda menentukan `remove_prompt_from_generated_text` sebagai`False`, teks yang dihasilkan akan dikembalikan tanpa token khusus yang Anda sertakan dalam kamus`special_token_dict`, seperti yang ditentukan oleh`skip_special_tokens=True`.
1. Uji Anda`ModelRunner`. Kirim permintaan sampel ke model Anda.
Contoh berikut menunjukkan cara menguji model menggunakan model `gpt2` pra-terlatih dari Hugging Face `AutoConfig` kelas:
```
hf_config = HFModelConfig(model_name="gpt2", max_new_tokens=32)
model = HuggingFaceCausalLLMModelRunner(model_config=hf_config)
```
Dalam contoh kode sebelumnya, `model_name` tentukan nama model pra-terlatih. `HFModelConfig`Kelas ini dipakai sebagai hf\_config dengan nilai untuk parameter`max_new_tokens`, dan digunakan untuk menginisialisasi. `ModelRunner`
Jika Anda ingin menggunakan model pra-terlatih lainnyaHugging Face, pilih `pretrained_model_name_or_path` di `from_pretrained` bawah [AutoClass](https://huggingface.co/transformers/v3.5.1/model_doc/auto.html).
Terakhir, uji Anda`ModelRunner`. Kirim permintaan sampel ke model Anda seperti yang ditunjukkan pada contoh kode berikut:
```
model_output = model.predict("London is the capital of?")[0]
print(model_output)
eval_algo.evaluate_sample()
```