Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Gunakan `fmeval` pustaka untuk menjalankan evaluasi otomatis
Menggunakan `fmeval` perpustakaan dalam kode Anda sendiri memberi Anda fleksibilitas paling besar untuk menyesuaikan alur kerja Anda. Anda dapat menggunakan `fmeval` perpustakaan untuk mengevaluasi LLM apa pun, dan juga memiliki lebih banyak fleksibilitas dengan kumpulan data input kustom Anda. Langkah-langkah berikut menunjukkan cara mengatur lingkungan Anda dan cara menjalankan alur kerja awal dan disesuaikan menggunakan `fmeval` pustaka.
## Mulai menggunakan `fmeval` perpustakaan
Anda dapat mengonfigurasi evaluasi model foundation dan menyesuaikannya untuk kasus penggunaan di notebook Studio. Konfigurasi Anda bergantung pada jenis tugas yang dibuat untuk diprediksi oleh model fondasi Anda, dan bagaimana Anda ingin mengevaluasinya. FMEval mendukung generasi terbuka, ringkasan teks, menjawab pertanyaan, dan tugas klasifikasi. Langkah-langkah di bagian ini menunjukkan cara mengatur alur kerja awal. Alur kerja awal ini mencakup pengaturan lingkungan Anda dan menjalankan algoritme evaluasi menggunakan model fondasi Amazon Bedrock JumpStart atau Amazon dengan kumpulan data bawaan. Jika Anda harus menggunakan dataset input kustom dan alur kerja untuk kasus penggunaan yang lebih spesifik, lihat. [Sesuaikan alur kerja Anda menggunakan pustaka `fmeval`](clarify-foundation-model-evaluate-auto-lib-custom.md)
## Siapkan lingkungan Anda
Jika Anda tidak ingin menjalankan evaluasi model di buku catatan Studio, lewati ke langkah 11 di bagian **Mulai menggunakan Studio** berikut.
**Prasyarat**
+ Untuk menjalankan evaluasi model di UI Studio, peran AWS Identity and Access Management (IAM) Anda dan kumpulan data input apa pun harus memiliki izin yang benar. Jika Anda tidak memiliki peran Domain SageMaker AI atau IAM, ikuti langkah-langkahnya. [Panduan untuk mengatur dengan Amazon SageMaker AI](gs.md)
**Untuk mengatur izin untuk bucket Amazon S3 Anda**
Setelah domain dan peran Anda dibuat, gunakan langkah-langkah berikut untuk menambahkan izin yang diperlukan untuk mengevaluasi model Anda.
1. Buka konsol Amazon SageMaker AI di [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Di panel navigasi, masuk **S3** ke bilah pencarian di bagian atas halaman.
1. Pilih **S3** di bawah **Layanan**.
1. Pilih **Bucket** dari panel navigasi.
1. Di bagian **Bucket tujuan umum**, di bawah **Nama**, pilih nama bucket S3 yang ingin Anda gunakan untuk menyimpan input dan output model Anda di konsol. Jika Anda tidak memiliki bucket S3, lakukan hal berikut:
1. Pilih **Buat ember** untuk membuka halaman **Bucket Buat** baru.
1. Di bagian **Konfigurasi umum**, di bawah **AWS Wilayah**, pilih AWS wilayah tempat model pondasi Anda berada.
1. Beri nama bucket S3 Anda di kotak input di bawah **nama Bucket**.
1. Terima semua pilihan default.
1. Pilih **Buat ember**.
1. Di bagian **Bucket tujuan umum**, di bawah **Nama**, pilih nama bucket S3 yang Anda buat.
1. Pilih tab **Izin**.
1. Gulir ke bagian **Cross-Origin Resource Sharing (CORS)** di bagian bawah jendela. Pilih **Edit**.
1. Untuk menambahkan izin ke bucket Anda untuk evaluasi foundation, pastikan kode berikut muncul di kotak input. Anda juga dapat menyalin dan menempelkan yang berikut ini ke dalam kotak input.
```
[
{
"AllowedHeaders": [
"*"
],
"AllowedMethods": [
"GET",
"PUT",
"POST",
"DELETE"
],
"AllowedOrigins": [
"*"
],
"ExposeHeaders": [
"Access-Control-Allow-Origin"
]
}
]
```
1. Pilih **Simpan perubahan**.
**Untuk menambahkan izin ke kebijakan IAM**
1. Di bilah pencarian di bagian atas halaman, masukkan**IAM**.
1. Di bawah **Layanan**, pilih **Identity and Access Management (IAM).**
1. Pilih **Kebijakan** dari panel navigasi.
1. Masukkan [AmazonSageMakerFullAccess](https://docs.aws.amazon.com/sagemaker/latest/dg/security-iam-awsmanpol.html#security-iam-awsmanpol-AmazonSageMakerFullAccess)ke dalam bilah pencarian. Pilih tombol radio di sebelah kebijakan yang muncul. Tombol **Actions** sekarang dapat dipilih.
1. Pilih panah bawah di sebelah **Tindakan**. Dua opsi muncul.
1. Pilih **Lampirkan**.
1. Di daftar IAM yang muncul, cari nama peran yang Anda buat. Pilih kotak centang di sebelah nama.
1. Pilih **Lampirkan kebijakan**.
**Mulai menggunakan Studio**
1. Di bilah pencarian di bagian atas halaman, masukkan**SageMaker AI**.
1. Di bawah **Layanan**, pilih **Amazon SageMaker AI**.
1. Pilih **Studio** dari panel navigasi.
1. Pilih domain Anda dari bagian **Memulai**, setelah memperluas panah bawah di bawah **Pilih Domain**.
1. Pilih profil pengguna Anda dari bagian **Memulai** setelah memperluas panah bawah di bawah **Pilih profil pengguna**.
1. Pilih **Open Studio** untuk membuka landing page Studio.
1. Pilih browser file dari panel navigasi dan arahkan ke direktori root.
1. Pilih **Buat buku catatan**.
1. Di kotak dialog lingkungan notebook yang terbuka, pilih gambar **Data Science 3.0**.
1. Pilih **Pilih**.
1. Instal `fmeval` paket di lingkungan pengembangan Anda, seperti yang ditunjukkan pada contoh kode berikut:
```
!pip install fmeval
```
**catatan**
Instal `fmeval` perpustakaan ke lingkungan yang menggunakanPython 3.10. Untuk informasi selengkapnya tentang persyaratan yang diperlukan untuk menjalankan`fmeval`, lihat [`fmeval`dependensi](https://github.com/aws/fmeval/blob/main/pyproject.toml).
## Konfigurasi `ModelRunner`
FMEval menggunakan pembungkus tingkat tinggi yang dipanggil `ModelRunner` untuk menulis input, memanggil, dan mengekstrak output dari model Anda. `fmeval`Paket dapat mengevaluasi LLM apa pun, namun prosedur untuk mengkonfigurasi `ModelRunner` tergantung pada jenis model yang ingin Anda evaluasi. Bagian ini menjelaskan cara mengkonfigurasi `ModelRunner` untuk model JumpStart atau Amazon Bedrock. Jika Anda ingin menggunakan dataset input kustom dan kustom`ModelRunner`, lihat[Sesuaikan alur kerja Anda menggunakan pustaka `fmeval`](clarify-foundation-model-evaluate-auto-lib-custom.md).
### Gunakan JumpStart model
Untuk digunakan `ModelRunner` untuk mengevaluasi JumpStart model, membuat atau menyediakan titik akhir, tentukan model dan dataset bawaan, konfigurasi, dan uji. `ModelRunner`
**Tentukan JumpStart model dan konfigurasikan ModelRunner**
1. Berikan titik akhir dengan melakukan salah satu dari hal berikut:
+ Tentukan [EndpointName](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html#API_runtime_InvokeEndpoint_RequestSyntax)ke JumpStart titik akhir yang ada,`model_id`, dan`model_version`.
+ Tentukan `model_id` dan `model_version` untuk model Anda, dan buat JumpStart titik akhir.
Contoh kode berikut menunjukkan cara membuat endpoint untuk [https://aws.amazon.com/blogs/machine-learning/llama-2-foundation-models-from-meta-are-now-available-in-amazon-sagemaker-jumpstart/](https://aws.amazon.com/blogs/machine-learning/llama-2-foundation-models-from-meta-are-now-available-in-amazon-sagemaker-jumpstart/)yang tersedia melalui JumpStart.
```
import sagemaker
from sagemaker.jumpstart.model import JumpStartModel
#JumpStart model and version
model_id, model_version = "meta-textgeneration-llama-2-7b-f", "*"
my_model = JumpStartModel(model_id=model_id)
predictor = my_model.deploy()
endpoint_name = predictor.endpoint_name
# Accept the EULA, and test the endpoint to make sure it can predict.
predictor.predict({"inputs": [[{"role":"user", "content": "Hello how are you?"}]]}, custom_attributes='accept_eula=true')
```
Contoh kode sebelumnya mengacu pada EULA, yang merupakan singkatan dari end-use-license-agreement (EULA). EULA dapat ditemukan dalam deskripsi kartu model model yang Anda gunakan. Untuk menggunakan beberapa JumpStart model, Anda harus menentukan`accept_eula=true`, seperti yang ditunjukkan pada panggilan sebelumnya ke`predict`. Untuk informasi selengkapnya tentang EULA, lihat bagian **Lisensi dan sumber model** di. [Sumber model dan perjanjian lisensi](jumpstart-foundation-models-choose.md)
Anda dapat menemukan daftar JumpStart model yang tersedia di [Algoritma Bawaan dengan Tabel Model yang telah dilatih sebelumnya](https://sagemaker.readthedocs.io/en/stable/doc_utils/pretrainedmodels.html#built-in-algorithms-with-pre-trained-model-table).
1. Konfigurasikan `ModelRunner` dengan menggunakan`JumpStartModelRunner`, seperti yang ditunjukkan pada contoh konfigurasi berikut:
```
from fmeval.model_runners.sm_jumpstart_model_runner import JumpStartModelRunner
js_model_runner = JumpStartModelRunner(
endpoint_name=endpoint_name,
model_id=model_id,
model_version=model_version
)
```
Dalam contoh konfigurasi sebelumnya, gunakan nilai yang sama untuk`endpoint_name`,`model_id`, dan `model_version` yang Anda gunakan untuk membuat titik akhir.
1. Uji Anda`ModelRunner`. Kirim permintaan sampel ke model Anda seperti yang ditunjukkan pada contoh kode berikut:
```
js_model_runner.predict("What is the capital of London")
```
### Gunakan model Amazon Bedrock
Untuk mengevaluasi model Amazon Bedrock, Anda harus menentukan model dan kumpulan data bawaan, dan mengonfigurasinya. `ModelRunner`
**Tentukan model Amazon Bedrock dan konfigurasikan ModelRunner**
1. Untuk menentukan dan mencetak detail model, gunakan contoh kode berikut untuk model Titan yang tersedia melalui Amazon Bedrock:
```
import boto3
import json
bedrock = boto3.client(service_name='bedrock')
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
model_id = "amazon.titan-tg1-large"
accept = "application/json"
content_type = "application/json"
print(bedrock.get_foundation_model(modelIdentifier=modelId).get('modelDetails'))
```
Dalam contoh kode sebelumnya, `accept` parameter menentukan format data yang ingin Anda gunakan untuk mengevaluasi LLM Anda. `contentType`Menentukan format data input dalam permintaan. Hanya `MIME_TYPE_JSON` didukung untuk `accept` dan `contentType` untuk model Amazon Bedrock. Untuk informasi selengkapnya tentang parameter ini, lihat [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html#API_runtime_InvokeModelWithResponseStream_RequestSyntax).
1. Untuk mengkonfigurasi`ModelRunner`, gunakan`BedrockModelRunner`, seperti yang ditunjukkan dalam contoh konfigurasi berikut:
```
from fmeval.model_runners.bedrock_model_runner import BedrockModelRunner
bedrock_model_runner = BedrockModelRunner(
model_id=model_id,
output='results[0].outputText',
content_template='{"inputText": $prompt, "textGenerationConfig": \
{"maxTokenCount": 4096, "stopSequences": [], "temperature": 1.0, "topP": 1.0}}',
)
```
Parametrize `ModelRunner` konfigurasi sebagai berikut.
+ Gunakan nilai yang sama untuk `model_id` yang Anda gunakan untuk menyebarkan model.
+ Gunakan `output` untuk menentukan format `json` respons yang dihasilkan. Sebagai contoh, jika LLM Anda memberikan respons`[{"results": "this is the output"}]`, maka `output='results[0].outputText'` kembali`this is the output`.
+ Gunakan `content_template` untuk menentukan bagaimana LLM Anda berinteraksi dengan permintaan. Template konfigurasi berikut dirinci semata-mata untuk menjelaskan contoh konfigurasi sebelumnya, dan itu tidak diperlukan.
+ Dalam contoh konfigurasi sebelumnya, variabel `inputText` menentukan prompt, yang menangkap permintaan yang dibuat oleh pengguna.
+ Variabel `textGenerationConfig` menentukan bagaimana LLM menghasilkan tanggapan sebagai berikut:
+ Parameter `maxTokenCount` ini digunakan untuk membatasi panjang respons dengan membatasi jumlah token yang dikembalikan oleh LLM.
+ Parameter `stopSequences` ini digunakan untuk menentukan daftar urutan karakter yang memberi tahu LLM Anda untuk berhenti menghasilkan respons. Output model dihentikan saat pertama kali salah satu string yang terdaftar ditemui dalam output. Sebagai contoh, Anda dapat menggunakan urutan pengembalian carriage untuk membatasi respons model ke satu baris.
+ Parameter `topP` mengontrol keacakan dengan membatasi kumpulan token untuk dipertimbangkan saat membuat token berikutnya. Parameter ini menerima nilai antara `0.0` dan`1.0`. Nilai yang lebih tinggi dari `topP` memungkinkan untuk satu set yang berisi kosakata yang lebih luas dan nilai yang lebih rendah membatasi kumpulan token ke kata-kata yang lebih mungkin.
+ Parameter `temperature` mengontrol keacakan teks yang dihasilkan, dan menerima nilai positif. 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. Rentang khas untuk `temperature` kebohongan antara `0.2` dan`2.0`.
Untuk informasi selengkapnya tentang parameter untuk model pondasi Amazon Bedrock tertentu, lihat [Parameter inferensi untuk model pondasi](https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters.html#model-parameters-titan).
Format parameter content\$1template tergantung pada input dan parameter yang didukung oleh LLM Anda. Misalnya, [Anthropic’s Claude 2model](https://www.anthropic.com/index/claude-2) dapat mendukung yang berikut`content_template`:
```
"content_template": "{\"prompt\": $prompt, \"max_tokens_to_sample\": 500}"
```
Sebagai contoh lain, [model Falcon 7b](https://huggingface.co/tiiuae/falcon-7b) dapat mendukung yang berikut ini. `content_template`
```
"content_template": "{\"inputs\": $prompt, \"parameters\":{\"max_new_tokens\": \
10, \"top_p\": 0.9, \"temperature\": 0.8}}"
```
Terakhir, uji Anda`ModelRunner`. Kirim permintaan sampel ke model Anda seperti yang ditunjukkan pada contoh kode berikut:
```
bedrock_model_runner.predict("What is the capital of London?")
```
## Evaluasi model Anda
Setelah Anda mengkonfigurasi data Anda dan`ModelRunner`, Anda dapat menjalankan algoritma evaluasi pada tanggapan yang dihasilkan oleh LLM Anda. Untuk melihat daftar semua algoritma evaluasi yang tersedia, jalankan kode berikut:
```
from fmeval.eval_algo_mapping import EVAL_ALGORITHMS
print(EVAL_ALGORITHMS.keys())
```
Setiap algoritma memiliki evaluasi dan `evaluate_sample` metode. `evaluate`Metode ini menghitung skor untuk seluruh kumpulan data. `evaluate_sample`Metode ini mengevaluasi skor untuk satu contoh.
`evaluate_sample`Metode mengembalikan `EvalScore` objek. `EvalScore`objek berisi skor agregat tentang seberapa baik kinerja model Anda selama evaluasi. `evaluate_sample`Metode ini memiliki parameter opsional berikut:
+ `model_output`— Respons model untuk satu permintaan.
+ `model_input`— Prompt yang berisi permintaan ke model Anda.
+ `target_output`— Respon yang diharapkan dari prompt yang terkandung dalam`model_input`.
Contoh kode berikut menunjukkan cara menggunakan`evaluate_sample`:
```
#Evaluate your custom sample
model_output = model_runner.predict("London is the capital of?")[0]
eval_algo.evaluate_sample(target_output="UKEnglandUnited Kingdom", model_output=model_output)
```
`evaluate`Metode ini memiliki parameter opsional berikut:
+ `model`— Contoh `ModelRunner` menggunakan model yang ingin Anda evaluasi.
+ `dataset_config`— Konfigurasi dataset. Jika tidak `dataset_config` disediakan, model dievaluasi menggunakan semua kumpulan data bawaan yang dikonfigurasi untuk tugas ini.
+ `prompt_template`— Template yang digunakan untuk menghasilkan prompt. Jika tidak `prompt_template` disediakan, model Anda dievaluasi menggunakan templat prompt default.
+ `save`— Jika disetel ke`True`, respons cepat dan skor yang direkam disimpan ke file. `EvalAlgorithmInterface.EVAL_RESULTS_PATH` Default ke `False`.
+ `num_records`— Jumlah catatan yang diambil sampelnya secara acak dari dataset input untuk evaluasi. Default ke `300`.
`evaluate`Algoritma mengembalikan daftar `EvalOutput` objek yang dapat mencakup yang berikut:
+ `eval_name`— Nama algoritma evaluasi.
`dataset_name`— Nama dataset yang digunakan oleh algoritma evaluasi.
`prompt_template`— Template yang digunakan untuk menulis prompt yang digunakan jika parameter tidak `model_output` disediakan dalam kumpulan data. Untuk informasi selengkapnya, lihat `prompt_template` di ** JumpStart `ModelRunner`bagian Mengkonfigurasi a**.
`dataset_scores`— Skor agregat dihitung di seluruh kumpulan data.
`category_scores`— Daftar `CategoryScore` objek yang berisi skor untuk setiap kategori dalam kumpulan data.
`output_path`— Jalur lokal ke output evaluasi. Output ini berisi tanggapan cepat dengan skor evaluasi rekor.
`error`— Pesan kesalahan string untuk pekerjaan evaluasi yang gagal.
Dimensi berikut tersedia untuk evaluasi model:
+ Akurasi
+ Pengetahuan faktual
+ Stereotip cepat
+ Kekokohan semantik
+ Toksisitas
### Akurasi
Anda dapat menjalankan algoritma akurasi untuk menjawab pertanyaan, ringkasan teks, atau tugas klasifikasi. Algoritma berbeda untuk setiap tugas untuk mengakomodasi berbagai jenis input data dan masalah sebagai berikut:
+ Untuk tugas menjawab pertanyaan, jalankan `QAAccuracy` algoritma dengan `QAAccuracyConfig` file.
+ Untuk tugas ringkasan teks, jalankan `SummarizationAccuracy` algoritme dengan `SummarizationAccuracyConfig` file.
+ Untuk tugas klasifikasi, jalankan `ClassificationAccuracy` algoritme dengan file`ClassificationAccuracyConfig`.
`QAAccuracy`Algoritma mengembalikan daftar `EvalOutput` objek yang berisi satu skor akurasi untuk setiap sampel. Untuk menjalankan algoritma akurasi jawaban pertanyaan, buat instance a `QAAccuracygeConfig` dan teruskan salah satu `` atau `None` sebagai. `target_output_delimiter` Algoritma akurasi jawaban pertanyaan membandingkan respons yang dihasilkan model Anda dengan respons yang diketahui. Jika Anda masuk `` sebagai pembatas target, maka algoritme menilai respons sebagai benar jika menghasilkan konten yang dipisahkan oleh `` dalam jawabannya. Jika Anda lulus `None` atau string kosong sebagai`target_output_delimiter`, kode melempar kesalahan.
Panggil `evaluate` metode dan teruskan parameter yang Anda inginkan seperti yang ditunjukkan pada contoh kode berikut:
```
from fmeval.eval import get_eval_algorithm
from fmeval.eval_algorithms.qa_accuracy import QAAccuracy, QAAccuracyConfig
eval_algo = QAAccuracy(QAAccuracyConfig(target_output_delimiter="")))
eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True)
```
`SummarizationAccuracy`Algoritma mengembalikan daftar `EvalOutput` objek yang berisi skor untuk [https://huggingface.co/spaces/evaluate-metric/rouge](https://huggingface.co/spaces/evaluate-metric/rouge), [https://huggingface.co/spaces/evaluate-metric/meteor](https://huggingface.co/spaces/evaluate-metric/meteor), dan [https://huggingface.co/spaces/evaluate-metric/bertscore](https://huggingface.co/spaces/evaluate-metric/bertscore). Untuk informasi lebih lanjut tentang skor ini, lihat bagian Ringkasan teks di[Menggunakan kumpulan data yang cepat dan dimensi evaluasi yang tersedia dalam pekerjaan evaluasi model](clarify-foundation-model-evaluate-overview.md). Untuk menjalankan algoritma akurasi ringkasan teks, buat instance a `SummarizationAccuracyConfig` dan teruskan berikut ini:
+ Tentukan jenis [https://en.wikipedia.org/wiki/ROUGE_(metric)](https://en.wikipedia.org/wiki/ROUGE_(metric))metrik yang ingin Anda gunakan dalam evaluasi Anda`rouge_type`. Anda dapat memilih `rouge1`, `rouge2`, atau `rougeL`. Metrik ini membandingkan ringkasan yang dihasilkan dengan ringkasan referensi. ROUGE-1membandingkan ringkasan yang dihasilkan dan ringkasan referensi menggunakan unigram yang tumpang tindih (urutan satu item seperti “the”, “is”). ROUGE-2membandingkan ringkasan yang dihasilkan dan referensi menggunakan bigram (kelompok dua urutan seperti “yang besar”, “adalah rumah”). ROUGE-Lmembandingkan urutan kata pencocokan terpanjang. Untuk informasi selengkapnyaROUGE, lihat [ROUGE: A Package for Automatic Evaluation of Summaries](https://aclanthology.org/W04-1013.pdf).
+ Setel `use_stemmer_for_rouge` ke `True` atau`False`. Stemmer menghapus imbuhan dari kata-kata sebelum membandingkannya. Misalnya, stemmer menghilangkan imbuhan dari “berenang” dan “berenang” sehingga keduanya “berenang” setelah bertangkai.
+ Setel model\$1type\$1for\$1bertscore ke model yang ingin Anda gunakan untuk menghitung a. [https://huggingface.co/spaces/evaluate-metric/bertscore](https://huggingface.co/spaces/evaluate-metric/bertscore) [Anda dapat memilih [ROBERTA\$1MODEL atau MICROSOFT\$1DEBERTA\$1MODEL](https://huggingface.co/docs/transformers/model_doc/roberta) yang lebih canggih.](https://github.com/microsoft/DeBERTa)
Terakhir, panggil `evaluate` metode dan berikan parameter yang Anda inginkan seperti yang ditunjukkan pada contoh kode berikut:
```
from fmeval.eval import get_eval_algorithm
from fmeval.eval_algorithms.summarization_accuracy import SummarizationAccuracy, SummarizationAccuracyConfig
eval_algo = SummarizationAccuracy(SummarizationAccuracyConfig(rouge_type="rouge1",model_type_for_bertscore="MICROSOFT_DEBERTA_MODEL"))
eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True)
```
`ClassificationAccuracy`Algoritma mengembalikan daftar `EvalOutput` objek yang berisi akurasi klasifikasi, presisi, ingatan, dan skor akurasi seimbang untuk setiap sampel. Untuk informasi lebih lanjut tentang skor ini, lihat bagian **Klasifikasi** di[Menggunakan kumpulan data yang cepat dan dimensi evaluasi yang tersedia dalam pekerjaan evaluasi model](clarify-foundation-model-evaluate-overview.md). Untuk menjalankan algoritma akurasi klasifikasi, buat instance a `ClassificationAccuracyConfig` dan teruskan strategi rata-rata ke. `multiclass_average_strategy` Anda dapat memilih`micro`,`macro`,`samples`,`weighted`, atau`binary`. Nilai default-nya adalah `micro`. Kemudian, masukkan daftar yang berisi nama kolom yang berisi label sebenarnya untuk kategori klasifikasi Anda ke valid\$1labels. Terakhir, panggil `evaluate` metode dan berikan parameter yang Anda inginkan seperti yang ditunjukkan pada contoh kode berikut:
```
from fmeval.eval import get_eval_algorithm
from fmeval.eval_algorithms.classification_accuracy import ClassificationAccuracy, ClassificationAccuracyConfig
eval_algo = ClassificationAccuracy(ClassificationAccuracyConfig(multiclass_average_strategy="samples",valid_labels=["animal_type","plant_type","fungi_type"]))
eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True)
```
### Pengetahuan faktual
Anda dapat menjalankan algoritma pengetahuan faktual untuk generasi terbuka. Untuk menjalankan algoritma pengetahuan faktual, buat instance a `FactualKnowledgeConfig` dan secara opsional meneruskan string pembatas (secara default, ini adalah). `` Algoritma pengetahuan faktual membandingkan respons yang dihasilkan model Anda dengan respons yang diketahui. Algoritma menilai respons sebagai benar jika menghasilkan salah satu konten yang dipisahkan oleh pembatas dalam jawaban. Jika Anda lulus `None` sebagai`target_output_delimiter`, maka model harus menghasilkan respons yang sama dengan jawaban yang akan dinilai sebagai benar. Terakhir, panggil `evaluate` metode dan teruskan parameter yang Anda inginkan.
Pengetahuan faktual mengembalikan daftar `EvalScore` objek. Ini berisi skor agregat tentang seberapa baik model Anda mampu menyandikan pengetahuan faktual seperti yang dijelaskan di bagian ikhtisar **evaluasi model Foundation**. Skor berkisar antara `0` dan `1` dengan skor terendah sesuai dengan pengetahuan yang lebih rendah tentang fakta dunia nyata.
Contoh kode berikut menunjukkan cara mengevaluasi LLM Anda menggunakan algoritma pengetahuan faktual:
```
from fmeval.eval import get_eval_algorithm
from fmeval.eval_algorithms.factual_knowledge import FactualKnowledge, FactualKnowledgeConfig
eval_algo = FactualKnowledge(FactualKnowledgeConfig())
eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True)
```
### Stereotip cepat
Anda dapat menjalankan algoritma stereotip prompt untuk generasi terbuka. Untuk menjalankan algoritme stereotip prompt, Anda `DataConfig` harus mengidentifikasi kolom dalam kumpulan data input Anda yang berisi kalimat yang kurang stereotip `sent_less_input_location` dan kalimat yang lebih stereotip di. `sent_more_output_location` Untuk informasi selengkapnya`DataConfig`, lihat bagian **2 sebelumnya. Konfigurasikan `ModelRunner`**. Selanjutnya, panggil `evaluate` metode dan berikan parameter yang Anda inginkan.
Stereotip cepat mengembalikan daftar `EvalOutput` objek yang berisi skor untuk setiap catatan input dan skor keseluruhan untuk setiap jenis bias. Skor dihitung dengan membandingkan probabilitas kalimat stereotip yang semakin sedikit. Skor keseluruhan melaporkan seberapa sering model lebih menyukai kalimat stereotip karena model memberikan probabilitas yang lebih tinggi untuk lebih stereotip dibandingkan dengan kalimat yang kurang stereotip. Skor `0.5` menunjukkan bahwa model Anda tidak bias, atau bahwa ia lebih suka kalimat stereotip yang semakin sedikit pada tingkat yang sama. Skor lebih besar dari `0.5` menunjukkan bahwa model Anda cenderung menghasilkan respons yang lebih stereotip. Skor kurang dari `0.5` menunjukkan bahwa model Anda cenderung menghasilkan respons yang kurang stereotip.
Contoh kode berikut menunjukkan cara mengevaluasi LLM Anda menggunakan algoritma stereotip prompt:
```
from fmeval.eval import get_eval_algorithm
from fmeval.eval_algorithms.prompt_stereotyping import PromptStereotyping
eval_algo = PromptStereotyping()
eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True)
```
### Kekokohan semantik
Anda dapat menjalankan algoritma ketahanan semantik untuk FMEval tugas apa pun, namun model Anda harus deterministik. Model deterministik adalah model yang selalu menghasilkan output yang sama untuk input yang sama. Seseorang biasanya dapat mencapai determinisme dengan menetapkan benih acak dalam proses decoding. Algoritma berbeda untuk setiap tugas untuk mengakomodasi berbagai jenis input data dan masalah sebagai berikut:
+ Untuk generasi terbuka, penjawab pertanyaan, atau klasifikasi tugas, jalankan `GeneralSemanticRobustness` algoritme dengan `GeneralSemanticRobustnessConfig` file.
+ Untuk ringkasan teks, jalankan `SummarizationAccuracySemanticRobustness` algoritma dengan `SummarizationAccuracySemanticRobustnessConfig` file.
`GeneralSemanticRobustness`Algoritma mengembalikan daftar `EvalScore` objek yang berisi akurasi dengan nilai antara `0` dan `1` mengukur perbedaan antara output model yang terganggu dan tidak terganggu. Untuk menjalankan algoritma ketahanan semantik umum, buat instance a dan teruskan a. `GeneralSemanticRobustnessConfig` `perturbation_type` Anda dapat memilih salah satu dari berikut ini untuk`perturbation_type`:
+ `Butterfinger`— Gangguan yang meniru kesalahan ejaan menggunakan swap karakter berdasarkan jarak keyboard. Masukkan probabilitas bahwa karakter tertentu terganggu. Butterfinger adalah nilai default untuk`perturbation_type`.
+ `RandomUpperCase`— Gangguan yang mengubah sebagian kecil karakter menjadi huruf besar. Masukan desimal dari `0` ke. `1`
+ `WhitespaceAddRemove`— Probabilitas bahwa karakter spasi putih ditambahkan di depan karakter spasi non-putih menjadi putih.
Anda juga dapat menentukan parameter berikut:
+ `num_perturbations`— Jumlah gangguan untuk setiap sampel untuk dimasukkan ke dalam teks yang dihasilkan. Nilai default-nya `5`.
+ `butter_finger_perturbation_prob`— Probabilitas bahwa karakter terganggu. Digunakan hanya ketika `perturbation_type` itu`Butterfinger`. Nilai default-nya `0.1`.
+ `random_uppercase_corrupt_proportion`— Fraksi karakter yang akan diubah menjadi huruf besar. Digunakan hanya ketika `perturbation_type` itu`RandomUpperCase`. Nilai default-nya `0.1`.
+ `whitespace_add_prob`— Diberikan ruang putih, probabilitas untuk menghapusnya dari sampel. Digunakan hanya ketika `perturbation_type` itu`WhitespaceAddRemove`. Nilai default-nya `0.05`.
+ `whitespace_remove_prob`— Diberikan ruang non-putih, kemungkinan menambahkan spasi putih di depannya. Digunakan hanya ketika `perturbation_type` itu`WhitespaceAddRemove`. Nilai default-nya `0.1`.
Terakhir, panggil `evaluate` metode dan berikan parameter yang Anda inginkan seperti yang ditunjukkan pada contoh kode berikut:
```
from fmeval.eval import get_eval_algorithm
from fmeval.eval_algorithms.general_semantic_robustness import GeneralSemanticRobustness, GeneralSemanticRobustnessConfig
eval_algo = GeneralSemanticRobustness(GeneralSemanticRobustnessConfig(perturbation_type="RandomUpperCase",num_perturbations=2,random_uppercase_corrupt_proportion=0.3)))
eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True)
```
`SummarizationAccuracySemanticRobustness`Algoritma mengembalikan daftar `EvalScore` objek yang berisi perbedaan (atau delta) antara [https://huggingface.co/spaces/evaluate-metric/rouge](https://huggingface.co/spaces/evaluate-metric/rouge), [https://huggingface.co/spaces/evaluate-metric/meteor](https://huggingface.co/spaces/evaluate-metric/meteor), dan [https://huggingface.co/spaces/evaluate-metric/bertscore](https://huggingface.co/spaces/evaluate-metric/bertscore)nilai antara ringkasan yang dihasilkan dan referensi. Untuk informasi lebih lanjut tentang skor ini, lihat bagian **Ringkasan teks** di[Menggunakan kumpulan data yang cepat dan dimensi evaluasi yang tersedia dalam pekerjaan evaluasi model](clarify-foundation-model-evaluate-overview.md). Untuk menjalankan algoritma kekokohan semantik ringkasan teks, buat instance a dan teruskan a. `SummarizationAccuracySemanticRobustnessConfig` `perturbation_type`
Anda dapat memilih salah satu dari berikut ini untuk`perturbation_type`:
+ `Butterfinger`— Gangguan yang meniru kesalahan ejaan menggunakan swap karakter berdasarkan jarak keyboard. Masukkan probabilitas bahwa karakter tertentu terganggu. `Butterfinger`adalah nilai default untuk`perturbation_type`.
+ `RandomUpperCase`— Gangguan yang mengubah sebagian kecil karakter menjadi huruf besar. Masukan desimal dari `0` ke. `1`
+ `WhitespaceAddRemove`— Masukkan probabilitas bahwa karakter spasi putih ditambahkan di depan karakter spasi non-putih menjadi putih.
Anda juga dapat menentukan parameter berikut:
+ `num_perturbations`— Jumlah gangguan untuk setiap sampel untuk dimasukkan ke dalam teks yang dihasilkan. Default-nya adalah `5`.
+ `butter_finger_perturbation_prob`— Probabilitas bahwa karakter terganggu. Digunakan hanya ketika `perturbation_type` itu`Butterfinger`. Default-nya adalah `0.1`.
+ `random_uppercase_corrupt_proportion`— Fraksi karakter yang akan diubah menjadi huruf besar. Digunakan hanya ketika `perturbation_type` itu`RandomUpperCase`. Default-nya adalah `0.1`.
+ `whitespace_add_prob`— Diberikan ruang putih, probabilitas untuk menghapusnya dari sampel. Digunakan hanya ketika `perturbation_type` itu`WhitespaceAddRemove`. Default-nya adalah `0.05`.
+ `whitespace_remove_prob`— Diberikan ruang non-putih, kemungkinan menambahkan spasi putih di depannya. Digunakan hanya ketika `perturbation_type` adalah`WhitespaceAddRemove`, Default adalah`0.1`.
+ `rouge_type`— Metrik yang membandingkan ringkasan yang dihasilkan dengan ringkasan referensi. Tentukan jenis [https://en.wikipedia.org/wiki/ROUGE_(metric)](https://en.wikipedia.org/wiki/ROUGE_(metric))metrik yang ingin Anda gunakan dalam evaluasi Anda`rouge_type`. Anda dapat memilih`rouge1`,`rouge2`, atau`rougeL`. ROUGE-1membandingkan ringkasan yang dihasilkan dan ringkasan referensi menggunakan unigram yang tumpang tindih (urutan satu item seperti “the”, “is”). ROUGE-2membandingkan ringkasan yang dihasilkan dan referensi menggunakan bigram (kelompok dua urutan seperti “yang besar”, “adalah rumah”). ROUGE-Lmembandingkan urutan kata pencocokan terpanjang. Untuk informasi selengkapnyaROUGE, lihat [ROUGE: A Package for Automatic Evaluation of Summaries](https://aclanthology.org/W04-1013.pdf).
+ Setel `user_stemmer_for_rouge` ke `True` atau`False`. Stemmer menghapus imbuhan dari kata-kata sebelum membandingkannya. Misalnya, stemmer menghilangkan imbuhan dari “berenang” dan “berenang” sehingga keduanya “berenang” setelah bertangkai.
+ Setel `model_type_for_bertscore` ke model yang ingin Anda gunakan untuk menghitung a [https://huggingface.co/spaces/evaluate-metric/bertscore](https://huggingface.co/spaces/evaluate-metric/bertscore). [Anda dapat memilih [ROBERTA\$1MODEL atau MICROSOFT\$1DEBERTA\$1MODEL](https://huggingface.co/docs/transformers/model_doc/roberta) yang lebih canggih.](https://github.com/microsoft/DeBERTa)
Panggil `evaluate` metode dan teruskan parameter yang Anda inginkan seperti yang ditunjukkan pada contoh kode berikut:
```
from fmeval.eval import get_eval_algorithm
from fmeval.eval_algorithms.summarization_accuracy_semantic_robustness import SummarizationAccuracySemanticRobustness, SummarizationAccuracySemanticRobustnessConfig
eval_algo = SummarizationAccuracySemanticRobustness(SummarizationAccuracySemanticRobustnessConfig(perturbation_type="Butterfinger",num_perturbations=3,butter_finger_perturbation_prob=0.2)))
eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True)
```
### Toksisitas
Anda dapat menjalankan algoritma toksisitas untuk generasi terbuka, ringkasan teks, atau menjawab pertanyaan. Ada tiga kelas yang berbeda tergantung pada tugas.
+ Untuk generasi terbuka, jalankan algoritma Toxicity dengan file. `ToxicityConfig`
+ Untuk meringkas, gunakan kelas`Summarization_Toxicity`.
+ Untuk menjawab pertanyaan, gunakan kelas`QAToxicity`.
Algoritma toksisitas mengembalikan satu atau lebih daftar `EvalScore` objek (tergantung pada detektor toksisitas) yang berisi skor antara `0` dan. `1` Untuk menjalankan algoritme toksisitas, buat instance a `ToxicityConfig` dan teruskan model toksisitas yang akan digunakan untuk mengevaluasi model Anda terhadap in. `model_type` Anda dapat memilih yang berikut untuk`model_type`:
+ [`detoksify` untuk UnitaryAI Detoxify-unbias, pengklasifikasi teks multilabel yang dilatih tentang Tantangan Klasifikasi Komentar Beracun dan Bias Tidak Disengaja](https://github.com/unitaryai/detoxify) [https://www.kaggle.com/c/jigsaw-toxic-comment-classification-challenge](https://www.kaggle.com/c/jigsaw-toxic-comment-classification-challenge) Model ini memberikan `7` skor untuk kelas-kelas berikut: toksisitas, toksisitas parah, kecabulan, ancaman, penghinaan, eksplisit seksual, dan serangan identitas.
Berikut ini adalah contoh output dari model detoksiitas:
```
EvalScore(name='toxicity', value=0.01936926692724228),
EvalScore(name='severe_toxicity', value=3.3755677577573806e-06),
EvalScore(name='obscene', value=0.00022437423467636108),
EvalScore(name='identity_attack', value=0.0006707844440825284),
EvalScore(name='insult', value=0.005559926386922598),
EvalScore(name='threat', value=0.00016682750720065087),
EvalScore(name='sexual_explicit', value=4.828436431125738e-05)
```
+ [`toxigen` untuk Toksigen-Roberta, pengklasifikasi teks BERTa berbasis Ro biner yang disetel dengan baik pada ToxiGen kumpulan data, yang berisi kalimat dengan toksisitas](https://github.com/microsoft/TOXIGEN) halus dan implisit yang berkaitan dengan kelompok minoritas. `13`
Terakhir, panggil `evaluate` metode dan berikan parameter yang Anda inginkan seperti yang ditunjukkan pada contoh kode berikut.
```
from fmeval.eval import get_eval_algorithm
from fmeval.eval_algorithms.toxicity import Toxicity, ToxicityConfig
eval_algo = Toxicity(ToxicityConfig(model_type="detoxify"))
eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True)
```