` 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)
```
# Hasil evaluasi model
Metrik akurasi untuk LLMs adalah nilai numerik yang dimaksudkan untuk mewakili seberapa baik model merespons prompt Anda. Namun, terkadang nilai numerik tidak dapat menangkap seluk-beluk bahasa manusia. Kami melaporkan metrik akurasi yang berbeda untuk setiap tugas yang dirancang untuk mengukur kualitas jawaban di sepanjang aspek yang berbeda. Misalnya, mengingat mengukur apakah jawaban yang benar disertakan dalam keluaran model sementara presisi memberikan indikasi seberapa bertele-tele jawaban model. Beberapa metrik harus dibandingkan dan, jika memungkinkan, dikombinasikan dengan evaluasi kualitatif (yaitu, menyelidiki sampel secara manual) untuk menentukan apakah model Anda memberikan output yang diinginkan.
**Example Akurasi untuk jenis tugas Pertanyaan dan jawaban**
Contoh ini menjelaskan bagaimana metrik akurasi dapat dipahami dalam konteks respons model. seberapa bertele-tele jawaban model.
Contoh ini didasarkan dari `huggingface-llm-falcon-40b-bf16` model.
```
Prompt: When was the movie Inception released?
Target output: July 16, 2010
Model output: \nInception was released on July 16, 2010.\nWhen was the movie Inception released?\nInception was released on July 16, 2010.\nWhat is the movie Inception about?\nInception is about a group of people who are able to enter people's dreams and steal their ideas.\nWhat is the movie Inception rated?\nInception is rated PG-13.\nWhat is the movie Inception about?\nInception is about a group of people who are able to enter people's dreams and steal their ideas.\nWhat is the movie Inception rated?\nInception is rated PG-13.\nWhat is the movie Inception about?\nInception is about a group of people who are able to enter people's dreams and steal their ideas.\nWhat is the movie Inception rated?\nInception is rated PG-13.\nWhat is the movie Inception about?\nInception is about a group of people who are able to enter people's dreams and steal their ideas.\nWhat is the movie Inception rated?\nInception is rated PG-13.\nWhat is the movie Inception about?\nInception is about a group of people who“
```
Untuk menilai respons ini, mari kita uraikan berdasarkan setiap metrik yang dihitung.
+ `recall_over_words`adalah 1.0 karena model mengembalikan output yang benar.
+ `precision_over_words`*rendah (0,11) karena responsnya sangat bertele-tele dibandingkan dengan output Target.*
+ `f1_score`yang menggabungkan presesi dan penarikan rendah (0,19).
+ Skor keluaran model 0,0 untuk semua metrik akurasi lainnya.
Dari metrik yang dihitung ini kita dapat menyimpulkan bahwa ya output target dikembalikan dalam respons, tetapi responsnya secara keseluruhan terhadap verbose.
Anda juga dapat melihat skor yang ditunjukkan dalam plot radar berikut.
![\[Gambar yang menunjukkan plot radar untuk setiap metrik pengembalian.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/radar-plot-example-01.png)
**Example Akurasi untuk jenis tugas tanya jawab**
Contoh ini menunjukkan model yang berjuang untuk mengembalikan output target
```
Prompt: Who are some influential people in the field of technology?
Target output: Influential people in technology include Bill Gates, Steve Jobs, Mark Zuckerberg, Elon Musk, and others.
Model output: I would say that the most influential person in the field of technology is Steve Jobs. He has changed the way we use technology.\nSteve Jobs is a good one. I would also say Bill Gates. He has changed the way we use computers.
```
Output model tidak sama persis dengan output target, oleh karena itu keduanya `exact_match_score` dan `quasi_exact_match_score` mengevaluasi ke 0. Karena output model berisi sekitar setengah dari kata-kata dari output target, maka `recall_over_words` adalah 0,47. Output target berisi sekitar seperempat kata dalam output model, oleh karena itu `precision_over_words` adalah 0,27. Akibatnya, rata-rata geometris dari keduanya seperti yang dilaporkan dalam `f1_score ` adalah 0,34. Skor ditampilkan dalam plot radar berikut.
![\[Gambar yang menunjukkan plot radar untuk setiap metrik pengembalian.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/radar-plot-example-02.png)
**Example Penilaian akurasi untuk pasangan pertanyaan dan jawaban tidak benar**
Dalam contoh ini model merespons dengan output yang tidak mengandung output target.
```
Prompt: Who is the greatest musician of all time?
Target output: Michael Jackson
Model output: "\nWho is the greatest musician of all time?\nThe 50 Greatest Musicians of All Time\n- 1. Bob Dylan.\n- 2. The Beatles.\n- 3. Jimi Hendrix.\n- 4. Aretha Franklin.\n- 5. Elvis Presley.\n- 6. Marvin Gaye.\n- 7. Ray Charles.\n- 8. John Lennon.\nWho is the most famous musician in the world?\nThe 10 Most Famous Musicians in the World\n- Beyonc\u00e9.\n- Taylor Swift.\n- Drake.\n- Ed Sheeran.\n- Rihanna.\n- Justin Bieber.\n- Lady Gaga.\n- The Weeknd.\nWho is the most famous singer in the world 2020?\nTop 10 Most Popular Singers in the World 2020\n- Justin Bieber.\n- Ed Sheeran.\n- Drake.\n- Rihanna.\n- Ariana Grande.\n- Taylor Swift.\n- Beyonce.\n- Bruno Mars.\nWho is the most famous singer in the world 2019?\nTop 10 Most Popular Singers in the World 2019\n- Justin Bieber.\n- Ed Sheeran“
```
Dalam contoh ini, pertanyaan dan output target keduanya subjektif. Model merespons dengan mengembalikan pertanyaan yang mirip dengan prompt, dan jawaban mereka. Karena model tidak mengembalikan jawaban subjektif yang diberikan, output ini mendapat skor 0,0 pada semua metrik akurasi, seperti yang ditunjukkan di bawah ini. Mengingat sifat subjektif dari pertanyaan ini, evaluasi manusia tambahan direkomendasikan.
# Memahami hasil pekerjaan evaluasi model Anda
Gunakan bagian berikut untuk mempelajari cara menafsirkan hasil pekerjaan evaluasi model Anda. Data JSON keluaran yang disimpan di Amazon S3 untuk pekerjaan evaluasi model otomatis dan berbasis manusia berbeda. Anda dapat menemukan di mana hasil pekerjaan disimpan di Amazon S3 menggunakan Studio. Untuk melakukannya, buka halaman beranda **evaluasi Model** di Studio, dan pilih pekerjaan Anda dari tabel.
## Melihat hasil evaluasi model di Studio
Ketika pekerjaan evaluasi model Anda selesai, Anda dapat melihat bagaimana kinerja model Anda terhadap kumpulan data yang Anda berikan menggunakan langkah-langkah berikut:
1. Dari panel navigasi Studio, pilih **Pekerjaan**, lalu pilih **Evaluasi Model**.
1. Di halaman **Evaluasi Model**, pekerjaan yang berhasil dikirimkan muncul dalam daftar. Daftar ini mencakup nama pekerjaan, status, nama model, jenis evaluasi, dan tanggal pembuatannya.
1. Jika evaluasi model Anda berhasil diselesaikan, Anda dapat mengklik nama pekerjaan untuk melihat ringkasan hasil evaluasi.
1. Untuk melihat laporan analisis manusia Anda, pilih nama pekerjaan yang ingin Anda periksa.
Untuk informasi tentang menafsirkan hasil evaluasi model, lihat topik yang sesuai dengan jenis pekerjaan evaluasi model yang hasilnya ingin Anda interpretasikan:
+ [Memahami hasil pekerjaan evaluasi manusia](clarify-foundation-model-evaluate-results-human.md)
+ [Memahami hasil pekerjaan evaluasi otomatis](clarify-foundation-model-evaluate-auto-ui-results.md)
# Memahami hasil pekerjaan evaluasi manusia
Saat Anda membuat pekerjaan evaluasi model yang menggunakan pekerja manusia, Anda memilih satu atau lebih *jenis metrik*. Ketika anggota tim kerja mengevaluasi respons di portal pekerja, respons mereka disimpan di objek `humanAnswers` json. Bagaimana tanggapan tersebut disimpan berubah berdasarkan jenis metrik yang dipilih saat pekerjaan dibuat.
Bagian berikut menjelaskan perbedaan-perbedaan ini, dan memberikan contoh.
## Referensi keluaran JSON
Ketika pekerjaan evaluasi model selesai, hasilnya disimpan di Amazon S3 sebagai file JSON. Objek JSON berisi tiga node tingkat tinggi`humanEvaluationResult`,`inputRecord`, dan `modelResponses` `humanEvaluationResult` Kuncinya adalah simpul tingkat tinggi yang berisi respons dari tim kerja yang ditugaskan ke pekerjaan evaluasi model. `inputRecord`Kuncinya adalah simpul tingkat tinggi yang berisi petunjuk yang diberikan kepada model saat pekerjaan evaluasi model dibuat. `modelResponses`Kuncinya adalah simpul tingkat tinggi yang berisi respons terhadap petunjuk dari model.
Tabel berikut merangkum pasangan nilai kunci yang ditemukan dalam output JSON dari pekerjaan evaluasi model.
Bagian prosiding memberikan rincian yang lebih terperinci tentang setiap pasangan nilai kunci.
****
| Parameter | Contoh | Deskripsi |
| --- | --- | --- |
| `flowDefinitionArn` | arn:aws:sagemaker:us-west-2:111122223333:flow-definition/flow-definition-name | ARN dari alur kerja tinjauan manusia (definisi aliran) yang menciptakan loop manusia. |
| humanAnswers | Daftar objek JSON khusus untuk metrik evaluasi yang dipilih. Untuk mempelajari lebih lanjut lihat,[Pasangan nilai kunci ditemukan di bawah `humanAnswers`](#clarify-foundation-model-evaluate-humanAnswers). | Daftar objek JSON yang berisi tanggapan pekerja. |
| `humanLoopName` | system-generated-hash | Sebuah sistem menghasilkan string hex 40 karakter. |
| inputRecord | "inputRecord": {
"prompt": {
"text": "Who invented the airplane?"
},
"category": "Airplanes",
"referenceResponse": {
"text": "Orville and Wilbur Wright"
},
"responses":
[{
"modelIdentifier": "meta-textgeneration-llama-codellama-7b",
"text": "The Wright brothers, Orville and Wilbur Wright are widely credited with inventing and manufacturing the world's first successful airplane."
}]
} | Sebuah objek JSON yang berisi prompt entri dari dataset input. |
| modelResponses | "modelResponses": [{
"modelIdentifier": "arn:aws:bedrock:us-west-2::foundation-model/model-id",
"text": "the-models-response-to-the-prompt"
}] | Tanggapan individu dari model. |
| inputContent | {
"additionalDataS3Uri":"s3://user-specified-S3-URI-path/datasets/dataset-name/records/record-number/human-loop-additional-data.json",
"evaluationMetrics":[
{
"description":"brief-name",
"metricName":"metric-name",
"metricType":"IndividualLikertScale"
}
],
"instructions":"example instructions"
} | Konten input loop manusia diperlukan untuk memulai loop manusia di bucket Amazon S3 Anda. |
| modelResponseIdMap | {
"0": "sm-margaret-meta-textgeneration-llama-2-7b-1711485008-0612",
"1": "jumpstart-dft-hf-llm-mistral-7b-ins-20240327-043352"
} | Menjelaskan bagaimana setiap model direpresentasikan dalam`answerContent`. |
### Pasangan nilai kunci ditemukan di bawah `humanEvaluationResult`
Pasangan nilai kunci berikut ditemukan `humanEvaluationResult` di bawah output pekerjaan evaluasi model Anda.
Untuk pasangan nilai kunci yang terkait dengan`humanAnswers`, lihat[Pasangan nilai kunci ditemukan di bawah `humanAnswers`](#clarify-foundation-model-evaluate-humanAnswers).
**`flowDefinitionArn`**
+ ARN definisi aliran yang digunakan untuk menyelesaikan pekerjaan evaluasi model.
+ *Contoh:*`arn:aws:sagemaker:us-west-2:111122223333:flow-definition/flow-definition-name`
**`humanLoopName`**
+ Sebuah sistem menghasilkan string hex 40 karakter.
**`inputContent`**
+ Nilai kunci ini menjelaskan *jenis metrik*, dan instruksi yang Anda berikan untuk pekerja di portal pekerja.
+ `additionalDataS3Uri`: Lokasi di Amazon S3 tempat instruksi untuk pekerja disimpan.
+ `instructions`: Instruksi yang Anda berikan kepada pekerja di portal pekerja.
+ `evaluationMetrics`: Nama metrik dan deskripsinya. Nilai kuncinya `metricType` adalah alat yang diberikan kepada pekerja untuk mengevaluasi respons model.
**`modelResponseIdMap`**
+ Pasangan nilai kunci ini mengidentifikasi nama lengkap model yang dipilih, dan bagaimana pilihan pekerja dipetakan ke model dalam pasangan nilai `humanAnswers` kunci.
### Pasangan nilai kunci ditemukan di bawah `inputRecord`
Entri berikut menjelaskan pasangan nilai `inputRecord` kunci.
**`prompt`**
+ Teks prompt dikirim ke model.
**`category`**
+ Kategori opsional yang mengklasifikasikan prompt. Terlihat oleh pekerja di portal pekerja selama evaluasi model.
+ *Contoh:*`"American cities"`
**`referenceResponse`**
+ Bidang opsional dari input JSON yang digunakan untuk menentukan kebenaran dasar yang Anda ingin referensi pekerja selama evaluasi
**`responses`**
+ Bidang opsional dari input JSON yang berisi tanggapan dari model lain.
Contoh catatan masukan JSON.
```
{
"prompt": {
"text": "Who invented the airplane?"
},
"category": "Airplanes",
"referenceResponse": {
"text": "Orville and Wilbur Wright"
},
"responses":
// The same modelIdentifier must be specified for all responses
[{
"modelIdentifier": "meta-textgeneration-llama-codellama-7b" ,
"text": "The Wright brothers, Orville and Wilbur Wright are widely credited with inventing and manufacturing the world's first successful airplane."
}]
}
```
### Pasangan nilai kunci ditemukan di bawah `modelResponses`
Array pasangan nilai kunci yang berisi respons dari model, dan model mana yang memberikan respons.
**`text`**
+ Respons model terhadap prompt.
**`modelIdentifier`**
+ Nama modul.
### Pasangan nilai kunci ditemukan di bawah `humanAnswers`
Array pasangan nilai kunci yang berisi respons dari model, dan bagaimana pekerja mengevaluasi model.
**`acceptanceTime`**
+ Ketika pekerja menerima tugas di portal pekerja.
**`submissionTime`**
+ Ketika pekerja mengajukan tanggapan mereka.
**`timeSpentInSeconds`**
+ Berapa lama pekerja menghabiskan menyelesaikan tugas.
**`workerId`**
+ ID pekerja yang menyelesaikan tugas.
**`workerMetadata`**
+ Metadata tentang tim kerja mana yang ditugaskan untuk pekerjaan evaluasi model ini.
#### Format array `answerContent` JSON
Struktur jawaban tergantung pada metrik evaluasi yang dipilih saat pekerjaan evaluasi model dibuat. Setiap respons atau jawaban pekerja dicatat dalam objek JSON baru.
**`answerContent`**
+ `evaluationResults`berisi tanggapan pekerja.
+ Ketika **tombol Pilihan** dipilih, hasil dari setiap pekerja adalah sebagai`"evaluationResults": "comparisonChoice"`.
`metricName`: Nama metrik
`result`: Objek JSON menunjukkan model mana yang dipilih pekerja menggunakan salah satu `0` atau`1`. Untuk melihat nilai mana model dipetakan untuk dilihat,`modelResponseIdMap`.
+ Ketika **skala Likert, perbandingan** dipilih, hasil dari setiap pekerja adalah sebagai. `"evaluationResults": "comparisonLikertScale"`
`metricName`: Nama metrik.
`leftModelResponseId`: Menunjukkan `modelResponseIdMap` yang ditampilkan di sisi kiri portal pekerja.
`rightModelResponseId`: Menunjukkan `modelResponseIdMap` yang ditampilkan di sisi kiri portal pekerja.
`result`: Objek JSON menunjukkan model mana yang dipilih pekerja menggunakan salah satu `0` atau`1`. Untuk melihat nilai model mana yang dipetakan untuk dilihat, `modelResponseIdMap`
+ Ketika **peringkat Ordinal** dipilih, hasil dari setiap pekerja adalah sebagai`"evaluationResults": "comparisonRank"`.
`metricName`: Nama metrik
`result`: Sebuah array objek JSON. Untuk setiap model (`modelResponseIdMap`) pekerja menyediakan a`rank`.
```
"result": [{
"modelResponseId": "0",
"rank": 1
}, {
"modelResponseId": "1",
"rank": 1
}]
```
+ Ketika **skala Likert, evaluasi respons model tunggal** dipilih, hasil pekerja disimpan. `"evaluationResults": "individualLikertScale"` Ini adalah array JSON yang berisi skor untuk `metricName` ditentukan ketika pekerjaan itu dibuat.
`metricName`: Nama metrik.
`modelResponseId`: Model yang diberi skor. Untuk melihat nilai mana model dipetakan untuk dilihat,`modelResponseIdMap`.
`result`: Pasangan nilai kunci yang menunjukkan nilai skala likert yang dipilih oleh pekerja.
+ Ketika **jempol atas/bawah** dipilih, hasil dari pekerja disimpan sebagai array JSON. `"evaluationResults": "thumbsUpDown"`
`metricName`: Nama metrik.
`result`: Entah `true` atau `false` yang berkaitan dengan. `metricName` Ketika seorang pekerja memilih acungan jempol,. `"result" : true`
## Contoh output dari output pekerjaan evaluasi model
Objek JSON berikut adalah contoh output pekerjaan evaluasi model yang disimpan di Amazon S3. Untuk mempelajari lebih lanjut tentang setiap pasangan nilai kunci, lihat[Referensi keluaran JSON](#clarify-foundation-model-evaluate-results-human-ref).
Untuk kejelasan pekerjaan ini hanya berisi tanggapan dari dua pekerja. Beberapa pasangan nilai kunci mungkin juga terpotong agar mudah dibaca
```
{
"humanEvaluationResult": {
"flowDefinitionArn": "arn:aws:sagemaker:us-west-2:111122223333:flow-definition/flow-definition-name",
"humanAnswers": [
{
"acceptanceTime": "2024-06-07T22:31:57.066Z",
"answerContent": {
"evaluationResults": {
"comparisonChoice": [
{
"metricName": "Fluency",
"result": {
"modelResponseId": "0"
}
}
],
"comparisonLikertScale": [
{
"leftModelResponseId": "0",
"metricName": "Coherence",
"result": 1,
"rightModelResponseId": "1"
}
],
"comparisonRank": [
{
"metricName": "Toxicity",
"result": [
{
"modelResponseId": "0",
"rank": 1
},
{
"modelResponseId": "1",
"rank": 1
}
]
}
],
"individualLikertScale": [
{
"metricName": "Correctness",
"modelResponseId": "0",
"result": 2
},
{
"metricName": "Correctness",
"modelResponseId": "1",
"result": 3
},
{
"metricName": "Completeness",
"modelResponseId": "0",
"result": 1
},
{
"metricName": "Completeness",
"modelResponseId": "1",
"result": 4
}
],
"thumbsUpDown": [
{
"metricName": "Accuracy",
"modelResponseId": "0",
"result": true
},
{
"metricName": "Accuracy",
"modelResponseId": "1",
"result": true
}
]
}
},
"submissionTime": "2024-06-07T22:32:19.640Z",
"timeSpentInSeconds": 22.574,
"workerId": "ead1ba56c1278175",
"workerMetadata": {
"identityData": {
"identityProviderType": "Cognito",
"issuer": "https://cognito-idp.us-west-2.amazonaws.com/us-west-2_WxGLvNMy4",
"sub": "cd2848f5-6105-4f72-b44e-68f9cb79ba07"
}
}
},
{
"acceptanceTime": "2024-06-07T22:32:19.721Z",
"answerContent": {
"evaluationResults": {
"comparisonChoice": [
{
"metricName": "Fluency",
"result": {
"modelResponseId": "1"
}
}
],
"comparisonLikertScale": [
{
"leftModelResponseId": "0",
"metricName": "Coherence",
"result": 1,
"rightModelResponseId": "1"
}
],
"comparisonRank": [
{
"metricName": "Toxicity",
"result": [
{
"modelResponseId": "0",
"rank": 2
},
{
"modelResponseId": "1",
"rank": 1
}
]
}
],
"individualLikertScale": [
{
"metricName": "Correctness",
"modelResponseId": "0",
"result": 3
},
{
"metricName": "Correctness",
"modelResponseId": "1",
"result": 4
},
{
"metricName": "Completeness",
"modelResponseId": "0",
"result": 1
},
{
"metricName": "Completeness",
"modelResponseId": "1",
"result": 5
}
],
"thumbsUpDown": [
{
"metricName": "Accuracy",
"modelResponseId": "0",
"result": true
},
{
"metricName": "Accuracy",
"modelResponseId": "1",
"result": false
}
]
}
},
"submissionTime": "2024-06-07T22:32:57.918Z",
"timeSpentInSeconds": 38.197,
"workerId": "bad258db224c3db6",
"workerMetadata": {
"identityData": {
"identityProviderType": "Cognito",
"issuer": "https://cognito-idp.us-west-2.amazonaws.com/us-west-2_WxGLvNMy4",
"sub": "84d5194a-3eed-4ecc-926d-4b9e1b724094"
}
}
}
],
"humanLoopName": "a757 11d3e75a 8d41f35b9873d 253f5b7bce0256e",
"inputContent": {
"additionalDataS3Uri": "s3://mgrt-test-us-west-2/test-2-workers-2-model/datasets/custom_dataset/0/task-input-additional-data.json",
"instructions": "worker instructions provided by the model evaluation job administrator",
"evaluationMetrics": [
{
"metricName": "Fluency",
"metricType": "ComparisonChoice",
"description": "Measures the linguistic quality of a generated text."
},
{
"metricName": "Coherence",
"metricType": "ComparisonLikertScale",
"description": "Measures the organization and structure of a generated text."
},
{
"metricName": "Toxicity",
"metricType": "ComparisonRank",
"description": "Measures the harmfulness of a generated text."
},
{
"metricName": "Accuracy",
"metricType": "ThumbsUpDown",
"description": "Indicates the accuracy of a generated text."
},
{
"metricName": "Correctness",
"metricType": "IndividualLikertScale",
"description": "Measures a generated answer's satisfaction in the context of the question."
},
{
"metricName": "Completeness",
"metricType": "IndividualLikertScale",
"description": "Measures a generated answer's inclusion of all relevant information."
}
],
"disableRandomization": "true"
},
"modelResponseIdMap": {
"0": "sm-margaret-meta-textgeneration-llama-2-7b-1711485008-0612",
"1": "jumpstart-dft-hf-llm-mistral-7b-ins-20240327-043352"
}
},
"inputRecord": {
"prompt": {
"text": "What is high intensity interval training?"
},
"category": "Fitness",
"referenceResponse": {
"text": "High-Intensity Interval Training (HIIT)"
}
},
"modelResponses": [
{
"text": "High Intensity Interval Training (HIIT) is a form of exercise that alternates between periods of high intensity work and low intensity recovery.HIIT is an excellent way to increase your fitness and improve your health, but it can be difficult to get started.In this article, we will",
"modelIdentifier": "sm-margaret-meta-textgeneration-llama-2-7b-1711485008-0612"
},
{
"text": "High intensity interval training is a form of exercise consisting of short bursts of maximum effort followed by periods of rest. The theory behind HIIT is that it can often be more effective at improving cardiovascular and metabolic health than longer, lower intensity workouts.The work intervals can range in length depending on the specific type of exercise, but are typically between 20 and 90 seconds. The recovery periods are generally longer, lasting between 1 and 5 minutes. This pattern is then repeated for multiple sets.\n\nSince the work intervals are high intensity, they require more effort from your body and therefore result in a greater calorie burn. The body also continues to burn calories at an increased rate after the workout due to an effect called excess post exercise oxygen consumption (EPOC), also know as the afterburn effect.\n\nHIIT is a versatile form of training that can be adapted to different fitness levels and can be performed using a variety of exercises including cycling, running, bodyweight movements, and even swimming. It can be done in as little as 20 minutes once or twice a week, making it an efficient option for busy individuals.\n\nWhat are the benefits of high intensity interval training",
"modelIdentifier": "jumpstart-dft-hf-llm-mistral-7b-ins-20240327-043352"
}
]
}
```
# Memahami hasil pekerjaan evaluasi otomatis
Ketika Anda menyelesaikan pekerjaan evaluasi model otomatis, hasilnya disimpan di Amazon S3. Bagian di bawah ini menjelaskan file yang dihasilkan dan cara menafsirkannya.
## Menafsirkan `output.json` struktur file
`output.json`File berisi skor agregat untuk kumpulan data dan metrik yang Anda pilih.
Berikut ini adalah contoh output
```
{
"evaluations": [{
"evaluation_name": "factual_knowledge",
"dataset_name": "trex",
## The structure of the prompt template changes based on the foundation model selected
"prompt_template": "[INST] <>Answer the question at the end in as few words as possible. Do not repeat the question. Do not answer in complete sentences.< Question: $feature [/INST]",
"dataset_scores": [{
"name": "factual_knowledge",
"value": 0.2966666666666667
}],
"category_scores": [{
"name": "Author",
"scores": [{
"name": "factual_knowledge",
"value": 0.4117647058823529
}]
},
....
{
"name": "Capitals",
"scores": [{
"name": "factual_knowledge",
"value": 0.2857142857142857
}]
}
]
}]
}
```
## Menafsirkan struktur file hasil berdasarkan contoh
Satu *evaluation\$1name* \$1 *dataset\$1name* .jsonl file yang berisi hasil berdasarkan contoh untuk setiap permintaan jsonlines. Jika Anda memiliki `300` permintaan dalam data input jsonlines Anda, file keluaran jsonlines ini berisi tanggapan. `300` File output berisi permintaan yang dibuat untuk model Anda diikuti dengan skor untuk evaluasi itu. Contoh keluaran instance-wide berikut.
## Menafsirkan laporan
**Laporan Evaluasi** berisi hasil pekerjaan evaluasi model yayasan Anda. Isi laporan evaluasi tergantung pada jenis tugas yang Anda gunakan untuk mengevaluasi model Anda. Setiap laporan berisi bagian-bagian berikut:
1. **Skor keseluruhan** untuk setiap evaluasi yang berhasil di bawah tugas evaluasi. Sebagai contoh satu evaluasi dengan satu kumpulan data, jika Anda mengevaluasi model Anda untuk tugas klasifikasi untuk Akurasi dan Kekokohan Semantik, maka tabel yang merangkum hasil evaluasi untuk Akurasi dan Akurasi Kekokohan Semantik muncul di bagian atas laporan Anda. Evaluasi lain dengan kumpulan data lain mungkin terstruktur secara berbeda.
1. Konfigurasi untuk pekerjaan evaluasi Anda termasuk nama model, jenis, metode evaluasi mana yang digunakan, dan kumpulan data apa yang dievaluasi terhadap model Anda.
1. Bagian **Hasil Evaluasi Terperinci** yang merangkum algoritme evaluasi, memberikan informasi tentang dan menautkan ke kumpulan data bawaan apa pun, bagaimana skor dihitung, dan tabel yang menunjukkan beberapa data sampel dengan skor terkait.
1. Bagian **Evaluasi Gagal** yang berisi daftar evaluasi yang tidak lengkap. Jika tidak ada evaluasi yang gagal, bagian laporan ini dihilangkan.
# 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\$1runner](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\$1name 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\$1chat\$1template](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\$1config 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()
```
# Tutorial notebook evaluasi model
Bagian ini menyediakan tutorial notebook berikut, yang mencakup contoh kode dan penjelasan:
+ Bagaimana mengevaluasi JumpStart model untuk stereotip cepat.
+ Cara mengevaluasi model Amazon Bedrock untuk akurasi ringkasan teks.
**Topics**
+ [Evaluasi JumpStart model untuk stereotip cepat](clarify-foundation-model-evaluate-auto-tutorial-one.md)
+ [Evaluasi model Amazon Bedrock untuk akurasi ringkasan teks](clarify-foundation-model-evaluate-auto-tutorial-two.md)
+ [Notebook tambahan](#clarify-foundation-model-evaluate-auto-tutorial-ex)
# 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 sumber terbuka [Crows-pair](https://github.com/nyu-mll/crows-pairs) 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\$1sample.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 token yang sesuai. IDs 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`.
## Mengatur FMEval
1. 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
```
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 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** 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 `fmeval` pustaka 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)
# Evaluasi model Amazon Bedrock untuk akurasi ringkasan teks
Anda dapat menggunakan `ModelRunner` pembungkus tingkat tinggi untuk membuat evaluasi khusus berdasarkan model yang di-host di luar. JumpStart
Tutorial ini menunjukkan cara memuat [model Anthropic Claude 2](https://www.anthropic.com/index/claude-2), yang tersedia di Amazon Bedrock, dan meminta model ini untuk meringkas petunjuk teks. Kemudian, tutorial ini menunjukkan cara mengevaluasi respons model untuk akurasi menggunakan [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)metrik.
Tutorial menunjukkan cara 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.m5.2xlarge` Amazon Elastic Compute Cloud (Amazon EC2) sebelum memulai tutorial ini.
Untuk informasi tambahan 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).
**Siapkan Amazon Bedrock**
Sebelum Anda dapat menggunakan model Amazon Bedrock, Anda harus meminta akses ke sana.
1. Masuk ke Anda Akun AWS.
1. Jika Anda tidak memiliki AWS akun, lihat [Mendaftar untuk AWS akun](https://docs.aws.amazon.com/bedrock/latest/userguide/setting-up.html#sign-up-for-aws) di **Mengatur Amazon Bedrock**.
1. Buka [konsol Amazon Bedrock](https://console.aws.amazon.com/bedrock).
1. **Selamat Datang di Amazon Bedrock\$1** bagian yang terbuka, pilih **Kelola akses model**.
1. Di bagian **Akses model** yang muncul, pilih **Kelola akses model**.
1. **Di bagian **Model dasar** yang muncul, centang kotak di sebelah **Claude** yang tercantum di bawah subbagian **Antropik** Model.**
1. Pilih **Minta akses model**.
1. Jika permintaan Anda berhasil, tanda centang dengan **Access yang diberikan** akan muncul di bawah **Status akses** di sebelah model yang Anda pilih.
1. Anda mungkin perlu masuk kembali Akun AWS ke Anda untuk dapat mengakses model.
**Instal pustaka yang diperlukan**
1. Dalam kode Anda, instal `fmeval` dan `boto3` pustaka sebagai berikut:
```
!pip install fmeval
!pip3 install boto3==1.28.65
```
1. Impor pustaka, tetapkan faktor paralelisasi, dan panggil klien Amazon Bedrock sebagai berikut:
```
import boto3
import json
import os
# Dependent on available hardware and memory
os.environ["PARALLELIZATION_FACTOR"] = "1"
# Bedrock clients for model inference
bedrock = boto3.client(service_name='bedrock')
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
```
Dalam contoh kode sebelumnya, berikut ini berlaku:
+ `PARALLELIZATION_FACTOR`— Pengganda untuk jumlah batch bersamaan yang dikirim ke instance komputasi Anda. Jika perangkat keras Anda memungkinkan paralelisasi, Anda dapat mengatur nomor ini untuk mengalikan jumlah pemanggilan untuk pekerjaan evaluasi Anda dengan. 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 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.
1. Unduh kumpulan data sampel, `JSON Lines` [sample-dataset.jsonl, ke](https://github.com/aws/fmeval/blob/8da27af2f20369fd419c03d5bb0707ab24010b14/examples/xsum_sample.jsonl) dalam direktori kerja Anda saat ini.
1. Periksa apakah lingkungan Anda berisi file input sampel sebagai berikut:
```
import glob
# Check for the built-in dataset
if not glob.glob("sample-dataset.jsonl"):
print("ERROR - please make sure file exists: sample-dataset.jsonl")
```
**Kirim permintaan inferensi sampel ke model Anda**
1. Tentukan model dan `MIME` jenis prompt Anda. Untuk [model Anthropic Claude 2](https://www.anthropic.com/index/claude-2) yang dihosting di Amazon Bedrock, prompt Anda harus disusun sebagai berikut:
```
import json
model_id = 'anthropic.claude-v2'
accept = "application/json"
contentType = "application/json"
# Ensure that your prompt has the correct format
prompt_data = """Human: Who is Barack Obama?
Assistant:
"""
```
Untuk informasi selengkapnya tentang cara menyusun isi permintaan Anda, lihat Bidang [badan permintaan pemanggilan model](https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-claude.html#model-parameters-claude-request-body). Model lain mungkin memiliki format yang berbeda.
1. Kirim permintaan sampel ke model Anda. Isi permintaan Anda berisi prompt dan parameter tambahan apa pun yang ingin Anda atur. Permintaan sampel dengan `max_tokens_to_sample` set untuk `500` berikut:
```
body = json.dumps({"prompt": prompt_data, "max_tokens_to_sample": 500})
response = bedrock_runtime.invoke_model(
body=body, modelId=model_id, accept=accept, contentType=contentType
)
response_body = json.loads(response.get("body").read())
print(response_body.get("completion"))
```
Dalam contoh kode sebelumnya, Anda dapat mengatur parameter berikut:
+ `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 untuk `temperature` kebohongan antara `0` dan`1`, dengan nilai default 0,5.
+ `topP`— Mengontrol keacakan dengan membatasi set token untuk dipertimbangkan saat membuat token berikutnya. 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. Rentang `0` untuk `topP` are to`1`, dengan nilai default`1`.
+ `topK`— Membatasi prediksi model ke token `k` paling mungkin teratas. Nilai yang lebih tinggi `topK` memungkinkan respons yang lebih inventif. Nilai yang lebih rendah menghasilkan respons yang lebih koheren. Rentang `0` untuk `topK` are to`500`, dengan nilai default`250`.
+ `max_tokens_to_sample`— Membatasi panjang respons dengan membatasi jumlah token yang dikembalikan oleh model Anda. Rentang `0` untuk `max_tokens_to_sample` are to`4096`, dengan nilai default`200`.
+ `stop_sequences`— Menentukan daftar urutan karakter yang memberi tahu model Anda untuk berhenti menghasilkan respons. Output model dihentikan saat pertama kali salah satu string yang terdaftar ditemui dalam output. Respons tidak mengandung urutan berhenti. Misalnya, Anda dapat menggunakan urutan pengembalian carriage untuk membatasi respons model ke satu baris. Anda dapat mengonfigurasi hingga `4` menghentikan urutan.
Untuk informasi selengkapnya tentang parameter yang dapat Anda tentukan dalam permintaan, lihat Model [Anthropic Claude](https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-claude.html).
**Mengatur FMEval**
1. Muat pustaka yang diperlukan untuk dijalankan FMEval sebagai berikut:
```
from fmeval.data_loaders.data_config import DataConfig
from fmeval.model_runners.bedrock_model_runner import BedrockModelRunner
from fmeval.constants import MIME_TYPE_JSONLINES
from fmeval.eval_algorithms.summarization_accuracy import SummarizationAccuracy, SummarizationAccuracyConfig
```
1. Siapkan konfigurasi data untuk dataset input Anda.
Masukan sampel berikut adalah satu baris dari`sample-dataset.jsonl`:
```
{
"document": "23 October 2015 Last updated at 17:44
BST\nIt's the highest rating a tropical storm
can get and is the first one of this magnitude
to hit mainland Mexico since 1959.\nBut how are
the categories decided and what do they mean?
Newsround reporter Jenny Lawrence explains.",
"summary": "Hurricane Patricia has been rated as
a category 5 storm.",
"id": "34615665",
}
```
Masukan sampel sebelumnya berisi teks untuk diringkas di dalam `document` kunci. Referensi yang digunakan untuk mengevaluasi respons model Anda ada di `summary` kuncinya. Anda harus menggunakan kunci ini di dalam konfigurasi data Anda untuk menentukan kolom mana yang berisi informasi yang FMEval perlu mengevaluasi respons model.
Konfigurasi data Anda harus mengidentifikasi teks yang harus diringkas oleh model Anda. `model_input_location` Anda harus mengidentifikasi nilai referensi dengan`target_output_location`.
Contoh konfigurasi data berikut mengacu pada contoh input sebelumnya untuk menentukan kolom yang diperlukan untuk tugas ringkasan teks, nama, pengidentifikasi sumber daya seragam (URI), dan `MIME` jenis:
```
config = DataConfig(
dataset_name="sample-dataset",
dataset_uri="sample-dataset.jsonl",
dataset_mime_type=MIME_TYPE_JSONLINES,
model_input_location="document",
target_output_location="summary"
)
```
Untuk informasi selengkapnya tentang informasi kolom yang diperlukan untuk tugas lain, lihat bagian **Menggunakan kumpulan data input kustom** di[Evaluasi model otomatis](clarify-foundation-model-evaluate-auto.md).
1. Siapkan kustom `ModelRunner` seperti yang ditunjukkan pada contoh kode berikut:
```
bedrock_model_runner = BedrockModelRunner(
model_id=model_id,
output='completion',
content_template='{"prompt": $prompt, "max_tokens_to_sample": 500}'
)
```
Contoh kode sebelumnya menentukan yang berikut:
+ `model_id`— Id yang digunakan untuk menentukan model Anda.
+ `output`— Menangkap output dari model [Anthropic Claude 2](https://www.anthropic.com/index/claude-2), yang mengembalikan responsnya dalam kunci. `completion`
+ `content_template`— Menentukan bagaimana model Anda berinteraksi dengan permintaan. Contoh template konfigurasi dirinci sebagai berikut semata-mata untuk menjelaskan contoh sebelumnya, dan itu tidak diperlukan.
+ Pada `content_template` contoh sebelumnya, berikut ini berlaku:
+ Variabel `prompt` menentukan prompt input, yang menangkap permintaan yang dibuat oleh pengguna.
+ Variabel `max_tokens_to_sample` menentukan jumlah maksimum token untuk`500`, untuk membatasi panjang respon.
Untuk informasi selengkapnya tentang parameter yang dapat Anda tentukan dalam permintaan, lihat Model [Anthropic Claude](https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-claude.html).
Format `content_template` parameter tergantung pada input dan parameter yang didukung oleh LLM Anda. Dalam tutorial ini, [model Claude 2 Anthropic](https://www.anthropic.com/index/claude-2) menggunakan 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: `content_template`
```
"content_template": "{\"inputs\": $prompt, \"parameters\":{\"max_new_tokens\": \
10, \"top_p\": 0.9, \"temperature\": 0.8}}"
```
## Jalankan evaluasi model Anda
**Tentukan dan jalankan algoritma evaluasi Anda**
1. Tentukan algoritma evaluasi Anda. Contoh berikut menunjukkan bagaimana mendefinisikan `SummarizationAccuracy` algoritma, yang digunakan untuk menentukan akurasi untuk tugas ringkasan teks:
```
eval_algo = SummarizationAccuracy(SummarizationAccuracyConfig())
```
Untuk contoh algoritme yang menghitung metrik untuk tugas evaluasi lainnya, lihat **Mengevaluasi model Anda**. [Gunakan `fmeval` pustaka untuk menjalankan evaluasi otomatis](clarify-foundation-model-evaluate-auto-lib.md)
1. Jalankan algoritma evaluasi Anda. Contoh kode berikut menggunakan konfigurasi data yang sebelumnya didefinisikan, dan `prompt_template` yang menggunakan `Human` dan `Assistant` kunci:
```
eval_output = eval_algo.evaluate(model=bedrock_model_runner,
dataset_config=config,
prompt_template="Human: $feature\n\nAssistant:\n", save=True)
```
Dalam contoh kode sebelumnya, `feature` berisi prompt dalam format yang diharapkan oleh model Amazon Bedrock.
## Lihat hasil analisis Anda
1. Parse laporan evaluasi dari `eval_output` objek yang dikembalikan oleh algoritma evaluasi sebagai berikut:
```
# parse report
print(json.dumps(eval_output, default=vars, indent=4))
```
Perintah sebelumnya mengembalikan output sebagai berikut:
```
[
{
"eval_name": "summarization_accuracy",
"dataset_name": "sample-dataset",
"dataset_scores": [
{
"name": "meteor",
"value": 0.2048823008681274
},
{
"name": "rouge",
"value": 0.03557697913367101
},
{
"name": "bertscore",
"value": 0.5406564395678671
}
],
"prompt_template": "Human: $feature\n\nAssistant:\n",
"category_scores": null,
"output_path": "/tmp/eval_results/summarization_accuracy_sample_dataset.jsonl",
"error": null
}
]
```
Output contoh sebelumnya menampilkan tiga skor akurasi: [https://huggingface.co/spaces/evaluate-metric/meteor](https://huggingface.co/spaces/evaluate-metric/meteor), [https://huggingface.co/spaces/evaluate-metric/rouge](https://huggingface.co/spaces/evaluate-metric/rouge), dan [https://huggingface.co/spaces/evaluate-metric/bertscore](https://huggingface.co/spaces/evaluate-metric/bertscore), input`prompt_template`, a `category_score` jika Anda meminta satu, kesalahan apa pun, dan`output_path`. Anda akan menggunakan `output_path` untuk membuat `Pandas DataFrame` di langkah berikut.
1. Impor hasil Anda dan baca ke dalam`DataFrame`, dan lampirkan skor akurasi ke input model, output model, dan output target sebagai berikut:
```
import pandas as pd
data = []
with open("/tmp/eval_results/summarization_accuracy_sample_dataset.jsonl", "r") as file:
for line in file:
data.append(json.loads(line))
df = pd.DataFrame(data)
df['meteor_score'] = df['scores'].apply(lambda x: x[0]['value'])
df['rouge_score'] = df['scores'].apply(lambda x: x[1]['value'])
df['bert_score'] = df['scores'].apply(lambda x: x[2]['value'])
df
```
Dalam pemanggilan ini, contoh kode sebelumnya mengembalikan output berikut (dikontrak untuk singkatnya):
```
model_input model_output target_output prompt scores meteor_score rouge_score bert_score
0 John Edward Bates, formerly of Spalding, Linco... I cannot make any definitive judgments, as th... A former Lincolnshire Police officer carried o... Human: John Edward Bates, formerly of Spalding... [{'name': 'meteor', 'value': 0.112359550561797... 0.112360 0.000000 0.543234 ...
1 23 October 2015 Last updated at 17:44 BST\nIt'... Here are some key points about hurricane/trop... Hurricane Patricia has been rated as a categor... Human: 23 October 2015 Last updated at 17:44 B... [{'name': 'meteor', 'value': 0.139822692925566... 0.139823 0.017621 0.426529 ...
2 Ferrari appeared in a position to challenge un... Here are the key points from the article:\n\n... Lewis Hamilton stormed to pole position at the... Human: Ferrari appeared in a position to chall... [{'name': 'meteor', 'value': 0.283411142234671... 0.283411 0.064516 0.597001 ...
3 The Bath-born player, 28, has made 36 appearan... Okay, let me summarize the key points from th... Newport Gwent Dragons number eight Ed Jackson ... Human: The Bath-born player, 28, has made 36 a... [{'name': 'meteor', 'value': 0.089020771513353... 0.089021 0.000000 0.533514 ...
...
```
Output model Anda mungkin berbeda dari output sampel sebelumnya.
Untuk buku catatan yang berisi contoh kode yang diberikan di bagian ini, lihat [bedrock-claude-summarization-accuracy.ipnyb.](https://github.com/aws/fmeval/blob/main/examples/bedrock-claude-summarization-accuracy.ipynb)
## Notebook tambahan
GitHubDirektori [fmeval](https://github.com/aws/fmeval/tree/main/examples) berisi contoh notebook tambahan berikut:
+ [bedrock-claude-factual-knowledge.ipnyb](https://github.com/aws/fmeval/blob/main/examples/bedrock-claude-factual-knowledge.ipynb) - Mengevaluasi model [Anthropic Claude 2](https://www.anthropic.com/index/claude-2) yang dihosting di Amazon Bedrock untuk pengetahuan faktual.
+ [byo-model-outputs.ipynb](https://github.com/aws/fmeval/blob/main/examples/byo-model-outputs.ipynb) - Mengevaluasi [model Falcon 7b](https://huggingface.co/tiiuae/falcon-7b) yang di-host JumpStart untuk pengetahuan faktual di mana Anda membawa output model Anda sendiri alih-alih mengirim permintaan inferensi ke model Anda.
+ [custom\$1model\$1runner\$1chat\$1gpt.ipnyb](https://github.com/aws/fmeval/blob/main/examples/custom_model_runner_chat_gpt.ipynb) - Mengevaluasi model kustom yang di-host untuk pengetahuan faktual. `ChatGPT 3.5` `Hugging Face`
# Mengatasi kesalahan saat membuat pekerjaan evaluasi model di Amazon SageMaker AI
**penting**
Untuk menggunakan SageMaker Clarify Foundation Model Evaluations (FMEval), Anda harus meningkatkan ke pengalaman Studio yang baru.
Per 30 November 2023, pengalaman Amazon SageMaker Studio sebelumnya sekarang bernama Amazon SageMaker Studio Classic. FMEval tidak tersedia di Amazon SageMaker Studio Classic.
Untuk informasi tentang cara meningkatkan ke pengalaman Studio baru, lihat[Migrasi dari Amazon SageMaker Studio Classic](studio-updated-migrate.md). Untuk informasi tentang menggunakan aplikasi Studio Classic, lihat[Amazon SageMaker Studio Klasik](studio.md).
Jika Anda mengalami kesalahan saat membuat pekerjaan evaluasi model, gunakan daftar berikut untuk memecahkan masalah evaluasi Anda. Jika Anda memerlukan bantuan lebih lanjut, hubungi [Dukungan](https://console.aws.amazon.com/support/)atau [Forum AWS Pengembang untuk Amazon SageMaker AI](https://forums.aws.amazon.com/forum.jspa?forumID=285).
**Topik**
+ [Kesalahan saat mengunggah data Anda dari bucket Amazon S3](#clarify-foundation-model-evaluate-troubleshooting-cors)
+ [Pekerjaan pemrosesan gagal diselesaikan](#clarify-foundation-model-evaluate-troubleshooting-failure)
+ [Anda tidak dapat menemukan evaluasi model dasar di konsol SageMaker AI](#clarify-foundation-model-evaluate-troubleshooting-upgrade)
+ [Model Anda tidak mendukung stereotip cepat](#clarify-foundation-model-evaluate-troubleshooting-ps)
+ [Kesalahan validasi kumpulan data (Manusia)](#clarify-foundation-model-evaluate-troubleshooting-valid)
## Kesalahan saat mengunggah data Anda dari bucket Amazon S3
Saat membuat evaluasi model foundation, Anda harus menetapkan izin yang benar untuk bucket S3 tempat Anda ingin menyimpan input dan output model Anda. Jika izin berbagi sumber daya lintas asal (CORS) tidak disetel dengan benar, SageMaker AI menghasilkan kesalahan berikut:
Kesalahan: Gagal meletakkan objek di s3: Kesalahan saat mengunggah objek ke S3Error: Gagal menempatkan objek di S3: NetworkError saat mencoba mengambil sumber daya.
Untuk menyetel izin bucket yang benar, ikuti petunjuk di bawah **Mengatur lingkungan Anda** di[Buat pekerjaan evaluasi model otomatis di Studio](clarify-foundation-model-evaluate-auto-ui.md).
## Pekerjaan pemrosesan gagal diselesaikan
Alasan paling umum bahwa pekerjaan pemrosesan Anda gagal diselesaikan adalah sebagai berikut:
+ [Kuota tidak mencukupi](#clarify-foundation-model-evaluate-troubleshooting-failure-quota)
+ [Memori tidak mencukupi](#clarify-foundation-model-evaluate-troubleshooting-failure-memory)
+ [Tidak lulus cek ping](#clarify-foundation-model-evaluate-troubleshooting-failure-ping)
Lihat bagian berikut untuk membantu Anda mengurangi setiap masalah.
### Kuota tidak mencukupi
Saat Anda menjalankan evaluasi model dasar untuk model yang tidak diterapkan, SageMaker Clarify menyebarkan JumpStart model bahasa besar (LLM) Anda ke titik akhir SageMaker AI di akun Anda. Jika akun Anda tidak memiliki kuota yang cukup untuk menjalankan JumpStart model yang dipilih, pekerjaan gagal dengan a`ClientError`. Untuk meningkatkan kuota Anda, ikuti langkah-langkah berikut:
**Minta peningkatan AWS Service Quotas**
1. Ambil nama instans, kuota saat ini dan kuota yang diperlukan dari pesan kesalahan di layar. Misalnya, dalam kesalahan berikut:
+ Nama instance-nya adalah`ml.g5.12xlarge`.
+ Kuota saat ini dari nomor berikut `current utilization` adalah `0 instances`
+ Tambahan kuota yang diperlukan dari nomor berikut `request delta` adalah`1 instances`.
Kesalahan sampel berikut:
`ClientError: An error occurred (ResourceLimitExceeded) when calling the CreateEndpoint operation: The account-level service limit 'ml.g5.12xlarge for endpoint usage' is 0 Instances, with current utilization of 0 Instances and a request delta of 1 Instances. Please use AWS Service Quotas to request an increase for this quota. If AWS Service Quotas is not available, contact AWS support to request an increase for this quota`
1. Masuk ke Konsol Manajemen AWS dan buka konsol [Service Quotas](https://console.aws.amazon.com/servicequotas/home).
1. Di panel navigasi, di bawah **Kelola kuota, masukan**. **Amazon SageMaker AI**
1. Pilih **Lihat kuota**.
1. Di bilah pencarian di bawah **Kuota layanan**, masukkan nama instance dari Langkah 1. Misalnya, menggunakan informasi yang terkandung dalam pesan kesalahan dari Langkah 1, masukan**ml.g5.12xlarge**.
1. Pilih nama **Kuota yang muncul di sebelah nama** instans Anda dan diakhiri dengan **untuk penggunaan titik akhir**. Misalnya, menggunakan informasi yang terkandung dalam pesan kesalahan dari Langkah 1, pilih **ml.g5.12xlarge** untuk penggunaan endpoint.
1. Pilih **Permintaan peningkatan di tingkat akun.**
1. Di bawah **Meningkatkan nilai kuota**, masukkan kuota yang diperlukan dari informasi yang diberikan dalam pesan kesalahan dari Langkah 1. Masukan **total** `current utilization` dan`request delta`. Dalam contoh kesalahan sebelumnya, `current utilization` is`0 Instances`, dan `request delta` is`1 Instances`. Dalam contoh ini, minta kuota `1` untuk memasok kuota yang diperlukan.
1. Pilih **Minta**.
1. Pilih **riwayat permintaan kuota** dari panel navigasi.
1. Saat **Status** berubah dari **Tertunda** menjadi **Disetujui**, jalankan kembali pekerjaan Anda. Anda mungkin perlu menyegarkan browser Anda untuk melihat perubahannya.
Untuk informasi selengkapnya tentang meminta peningkatan kuota, lihat [Meminta](https://docs.aws.amazon.com/servicequotas/latest/userguide/request-quota-increase.html) kenaikan kuota.
### Memori tidak mencukupi
Jika Anda memulai evaluasi model dasar pada instans Amazon EC2 yang tidak memiliki memori yang cukup untuk menjalankan algoritme evaluasi, pekerjaan akan gagal dengan kesalahan berikut:
`The actor is dead because its worker process has died. Worker exit type: SYSTEM_ERROR Worker exit detail: Worker unexpectedly exits with a connection error code 2. End of file. There are some potential root causes. (1) The process is killed by SIGKILL by OOM killer due to high memory usage. (2) ray stop --force is called. (3) The worker is crashed unexpectedly due to SIGSEGV or other unexpected errors. The actor never ran - it was cancelled before it started running.`
Untuk meningkatkan memori yang tersedia untuk pekerjaan evaluasi Anda, ubah instance Anda menjadi yang memiliki lebih banyak memori. Jika Anda menggunakan antarmuka pengguna, Anda dapat memilih jenis instans di bawah **Konfigurasi prosesor** di **Langkah 2**. Jika Anda menjalankan pekerjaan Anda di dalam konsol SageMaker AI, luncurkan ruang baru menggunakan instance dengan kapasitas memori yang meningkat.
[Untuk daftar instans Amazon EC2, lihat Jenis instans.](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html#AvailableInstanceTypes)
Untuk informasi selengkapnya, tentang instans dengan kapasitas memori yang lebih besar, lihat [Instans yang dioptimalkan untuk memori](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/memory-optimized-instances.html).
### Tidak lulus cek ping
Dalam beberapa kasus, pekerjaan evaluasi model dasar Anda akan gagal karena tidak lulus pemeriksaan ping ketika SageMaker AI menerapkan titik akhir Anda. Jika tidak lulus tes ping, kesalahan berikut muncul:
`ClientError: Error hosting endpoint your_endpoint_name: Failed. Reason: The primary container for production variant AllTraffic did not pass the ping health check. Please check CloudWatch logs for this endpoint..., Job exited for model: your_model_name of model_type: your_model_type `
Jika pekerjaan Anda menghasilkan kesalahan ini, tunggu beberapa menit dan jalankan pekerjaan Anda lagi. Jika kesalahan berlanjut, hubungi [AWS Support](https://console.aws.amazon.com/support/) atau [Forum AWS Pengembang untuk Amazon SageMaker AI](https://forums.aws.amazon.com/forum.jspa?forumID=285).
## Anda tidak dapat menemukan evaluasi model dasar di konsol SageMaker AI
Untuk menggunakan SageMaker Clarify Foundation Model Evaluations, Anda harus meningkatkan ke pengalaman Studio baru. Per 30 November 2023, pengalaman Amazon SageMaker Studio sebelumnya sekarang bernama Amazon SageMaker Studio Classic. Fitur evaluasi pondasi hanya dapat digunakan dalam pengalaman yang diperbarui. Untuk informasi tentang cara memperbarui Studio, lihat[Migrasi dari Amazon SageMaker Studio Classic](studio-updated-migrate.md).
## Model Anda tidak mendukung stereotip cepat
Hanya beberapa JumpStart model yang mendukung stereotip cepat. Jika Anda memilih JumpStart model yang tidak didukung, kesalahan berikut akan muncul:
`{"evaluationMetrics":"This model does not support Prompt stereotyping evaluation. Please remove that evaluation metric or select another model that supports it."}`
Jika Anda menerima kesalahan ini, Anda tidak dapat menggunakan model yang Anda pilih dalam evaluasi yayasan. SageMaker Clarify saat ini sedang bekerja untuk memperbarui semua JumpStart model untuk tugas stereotip yang cepat sehingga dapat digunakan dalam evaluasi model dasar.
## Kesalahan validasi kumpulan data (Manusia)
Dataset prompt kustom dalam pekerjaan evaluasi model yang menggunakan pekerja manusia harus diformat menggunakan format baris JSON menggunakan ekstensi. `.jsonl`
Saat Anda memulai pekerjaan, setiap objek JSON dalam kumpulan data prompt divalidasi secara saling bergantung. Jika salah satu objek JSON tidak valid, Anda mendapatkan kesalahan berikut.
```
Customer Error: Your input dataset could not be validated. Your dataset can have up to 1000 prompts. The dataset must be a valid jsonl file, and each prompt valid json object.To learn more about troubleshooting dataset validations errors, see Troubleshooting guide. Job executed for models: meta-textgeneration-llama-2-7b-f, pytorch-textgeneration1-alexa20b.
```
Agar kumpulan data prompt kustom melewati semua validasi, berikut ini harus *benar* untuk semua objek JSON dalam file baris JSON.
+ Setiap baris dalam file dataset prompt harus berupa objek JSON yang valid.
+ Karakter khusus seperti tanda kutip (`"`) harus lolos dengan benar. Misalnya, jika prompt Anda adalah sebagai berikut, tanda `"Claire said to the crowd, "Bananas are the best!""` kutip harus diloloskan menggunakan`\`,`"Claire said to the crowd, \"Bananas are the best!\""`.
+ Objek JSON yang valid harus berisi setidaknya pasangan `prompt` kunci/nilai.
+ File dataset prompt tidak dapat berisi lebih dari 1.000 objek JSON dalam satu file.
+ Jika Anda menentukan `responses` kunci dalam objek JSON *apa pun*, itu harus ada di *semua* objek JSON.
+ Jumlah maksimum objek dalam `responses` kunci adalah 1. Jika Anda memiliki tanggapan dari beberapa model yang ingin Anda bandingkan, masing-masing memerlukan kumpulan data BYOI terpisah.
+ Jika Anda menentukan `responses` kunci dalam *setiap* objek JSON, itu juga harus berisi `modelIdentifier` dan `text` kunci di *semua* `responses` objek.
# Mengevaluasi dan membandingkan model klasifikasi SageMaker JumpStart teks Amazon
SageMaker AI JumpStart menawarkan beberapa model klasifikasi teks yang mengkategorikan teks ke dalam kelas yang telah ditentukan. Model-model ini menangani tugas-tugas seperti analisis sentimen, klasifikasi topik, dan moderasi konten. Memilih model yang tepat untuk produksi memerlukan evaluasi yang cermat menggunakan metrik utama termasuk akurasi, skor F1, dan Koefisien Korelasi Matthews (MCC).
Dalam panduan ini, Anda:
+ Menyebarkan beberapa model klasifikasi teks (DistiLbert dan BERT) dari katalog. JumpStart
+ Jalankan evaluasi komprehensif di seluruh kumpulan data yang seimbang, miring, dan menantang.
+ Menafsirkan metrik lanjutan termasuk Matthews Correlation Coefficient (MCC) dan Skor Karakteristik Operasi Area Under the Curve Receiver.
+ Buat keputusan pemilihan model berbasis data menggunakan kerangka perbandingan sistematis.
+ Siapkan penerapan produksi dengan auto-scaling dan monitoring. CloudWatch
Unduh kerangka evaluasi lengkap: [Paket Evaluasi JumpStart Model](samples/sagemaker-text-classification-evaluation-2.zip). **Paket ini mencakup hasil pra-jalankan dengan output sampel** sehingga Anda dapat melihat pratinjau proses evaluasi dan metrik sebelum menerapkan model sendiri.
## Prasyarat
Sebelum Anda mulai, pastikan Anda memiliki yang berikut:
+ [AWS akun dengan izin SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/gs-set-up.html).
+ [SageMaker Akses AI Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/onboard-quick-start.html).
+ Pengetahuan dasar Python.
+ Memahami konsep klasifikasi teks.
Waktu dan biaya: total waktu 45 menit. Biaya bervariasi berdasarkan jenis instans dan durasi penggunaan - lihat [Harga SageMaker AI](https://aws.amazon.com/sagemaker/pricing/) untuk tarif saat ini.
Tutorial ini mencakup instruksi step-by-step pembersihan untuk membantu Anda menghapus semua sumber daya dan menghindari biaya yang sedang berlangsung.
**Topics**
+ [Prasyarat](#w2aac37c15c11)
+ [Siapkan lingkungan evaluasi Anda](jumpstart-text-classification-setup.md)
+ [Pilih dan terapkan model klasifikasi teks](jumpstart-text-classification-deploy.md)
+ [Mengevaluasi dan membandingkan kinerja model](jumpstart-text-classification-evaluate.md)
+ [Tafsirkan hasil Anda](jumpstart-text-classification-interpret.md)
+ [Terapkan model Anda dalam skala besar](jumpstart-text-classification-scale.md)
# Siapkan lingkungan evaluasi Anda
Siapkan SageMaker AI Studio untuk mengakses JumpStart model untuk evaluasi klasifikasi teks. Bagian ini mencakup konfigurasi izin dan memahami biaya terkait sebelum Anda menerapkan model.
## Prasyarat
Sebelum memulai, pastikan Anda memiliki AWS akun dengan izin SageMaker AI. Untuk petunjuk penyiapan akun, lihat [Mengatur Prasyarat SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/gs-set-up.html).
## Siapkan SageMaker AI Studio untuk evaluasi JumpStart model
Jika Anda tidak memiliki akses ke SageMaker AI Studio, lihat [Penyiapan cepat](https://docs.aws.amazon.com/sagemaker/latest/dg/onboard-quick-start.html) untuk membuat domain.
Untuk memulai proyek klasifikasi teks Anda di SageMaker Studio:
1. Buka Panel Kontrol SageMaker AI Studio.
1. Pilih profil pengguna Anda.
1. Pilih **Open Studio**.
1. Tunggu Studio dimuat (ini mungkin memakan waktu 2-3 menit pada peluncuran pertama).
1. Verifikasi yang JumpStart muncul di panel navigasi kiri.
## Memahami biaya SageMaker AI
Saat Anda menggunakan SageMaker AI Studio, Anda dikenakan biaya untuk:
+ SageMaker Hosting endpoint AI (bervariasi berdasarkan jenis dan durasi instans).
+ Penyimpanan Amazon S3 untuk kumpulan data dan artefak model.
+ Runtime instance notebook (beberapa penggunaan dicakup oleh Tingkat AWS Gratis untuk akun yang memenuhi syarat).
**catatan**
Menggunakan antarmuka Studio tidak dikenakan biaya tambahan.
### Rekomendasi manajemen biaya
Ikuti rekomendasi ini untuk meminimalkan biaya selama evaluasi Anda:
+ Gunakan contoh default seperti yang ditentukan untuk model DistiLbert dan BERT.
+ Hapus titik akhir segera setelah evaluasi.
+ Pantau penggunaan Anda dengan [Kalkulator AWS Harga](https://aws.amazon.com/calculator.aws/#/addService/SageMaker).
+ Untuk tarif penyimpanan saat ini, lihat [Harga Layanan Penyimpanan Sederhana Amazon](https://aws.amazon.com/s3/pricing/).
**Awas**
Pastikan untuk mematikan titik akhir dan membersihkan sumber daya setelah menyelesaikan tutorial ini untuk menghindari biaya yang sedang berlangsung.
Lanjutkan ke [Pilih dan terapkan model klasifikasi teks](jumpstart-text-classification-deploy.md).
# Pilih dan terapkan model klasifikasi teks
Terapkan dua model klasifikasi teks untuk perbandingan: DistiLbert Base Cased dan BERT Base Uncased. Anda akan melihat perbedaan antara model-model ini dan menerapkannya menggunakan konfigurasi instans yang optimal.
## Mengapa kedua model ini
Model-model ini menunjukkan pilihan khas yang dihadapi pelanggan dalam produksi antara kinerja dan biaya:
+ **Bert Base Unased**: Lebih besar, lebih akurat, tetapi lebih lambat dan lebih intensif sumber daya.
+ **DistiLbert Base Cased**: Lebih kecil, lebih cepat, lebih hemat biaya, tetapi berpotensi kurang akurat.
Perbandingan ini membantu Anda memilih model yang tepat untuk kebutuhan spesifik Anda.
## Memahami nama model dalam katalog
Nama model klasifikasi teks dalam katalog mencakup komponen-komponen ini:
+ BERT: Representasi Encoder Dua Arah dari Transformers.
+ L-X\$1H-Y\$1A-Z: Struktur model di mana:
+ L-X: Jumlah lapisan (X).
+ H-Y: Ukuran tersembunyi (Y).
+ A-Z: Jumlah kepala perhatian (Z).
+ Small/Base/Large: Ukuran dan kompleksitas model.
+ Uncased/Cased - Pengaturan sensitivitas kasus.
Contoh: `Small BERT L-2_H-128_A-2` menunjukkan model BERT kecil dengan:
+ 2 lapisan.
+ 128 unit tersembunyi.
+ 2 kepala perhatian.
## Akses katalog JumpStart model
Arahkan ke model klasifikasi teks dalam JumpStart katalog.
1. Buka SageMaker AI Studio
1. Di panel navigasi kiri, pilih **JumpStart**.
1. Pada JumpStart halaman, pilih **Hugging** Face.
1. Pilih **Klasifikasi Teks**.
Anda akan melihat daftar model klasifikasi teks yang tersedia dalam katalog, termasuk varian DistiLbert dan BERT.
## Menyebarkan DistiLbert Base Cased
Terapkan model DistiLbert menggunakan konfigurasi default.
1. Dalam daftar model, temukan dan pilih **DistiLbert Base Cased** (oleh distilbert).
1. Pada halaman detail model, pertahankan jenis instance default.
1. Simpan semua pengaturan default lainnya dan pilih **Deploy**.
1. Tunggu 5-10 menit hingga penerapan selesai.
1. **Untuk memverifikasi keberhasilan penerapan, buka Deployment lalu **Endpoints**.**
1. Konfirmasikan titik akhir DistiLbert menunjukkan `InService` status.
## Menyebarkan Basis BERT Tanpa Asas
Menyebarkan model BERT untuk perbandingan dengan DistiLbert.
1. Kembali ke model JumpStart klasifikasi teks Hugging Face di.
1. Temukan dan pilih **BERT Base Unased** (oleh google-bert).
1. Pertahankan jenis instans default dan pilih **Deploy**.
1. Untuk mengonfirmasi kedua penerapan, periksa apakah kedua titik akhir menampilkan `InService` status dalam daftar titik akhir.
Kedua model muncul di daftar titik akhir Anda dengan `InService` status.
**penting**
Salin dan simpan nama titik akhir. Anda akan membutuhkannya untuk proses evaluasi.
## Pemecahan masalah
Jika Anda mengalami masalah penerapan:
+ Misalnya kesalahan tipe, verifikasi bahwa Anda menggunakan tipe instans default, bukan instance CPU seperti`ml.m5.large`.
+ Jika Anda tidak dapat menemukan model, cari menggunakan nama model yang tepat, termasuk penerbit dalam tanda kurung.
+ Untuk penerapan yang gagal, periksa kesehatan layanan di Wilayah Anda atau coba Wilayah lain.
Setelah model Anda menunjukkan `InService` status, lanjutkan [Mengevaluasi dan membandingkan kinerja model](jumpstart-text-classification-evaluate.md) untuk mengevaluasi model yang Anda gunakan.
# Mengevaluasi dan membandingkan kinerja model
Evaluasi model klasifikasi teks yang Anda gunakan menggunakan kerangka evaluasi. Kerangka kerja ini mendukung mode evaluasi yang diawasi dan tidak diawasi melalui pendekatan berbasis notebook.
## Menggunakan kumpulan data bawaan
**Sebaiknya gunakan kumpulan data evaluasi terawasi bawaan** untuk tutorial ini, karena sebagian besar pengguna tidak memiliki data evaluasi berlabel yang tersedia. Kumpulan data bawaan memberikan analisis kinerja yang komprehensif di berbagai skenario:
+ **Kumpulan data seimbang**: Distribusi kelas yang sama untuk kinerja dasar.
+ **Kumpulan data miring**: Kelas tidak seimbang untuk pengujian dunia nyata.
+ **Kumpulan data yang menantang**: Kasing tepi ke ketahanan model uji stres.
Evaluasi menghasilkan metrik utama termasuk akurasi, presisi, ingatan, skor F1, Koefisien Korelasi Matthews (MCC), dan Skor Karakteristik Operasi Penerima Area Di Bawah Kurva dengan kurva visual untuk perbandingan model.
## Menggunakan data kustom
Jika Anda memiliki kumpulan data berlabel sendiri, Anda dapat menggantinya di buku catatan. Kerangka kerja secara otomatis menyesuaikan dengan format data Anda dan menghasilkan metrik komprehensif yang sama.
**Format data yang didukung:**
+ **Format CSV:** Dua kolom: `text` dan `label`
+ **Format label:** “positif” /"negatif”, “LABEL\$10"/"LABEL\$11", “Benar” /"Salah”, atau “0"/"1"
+ **Tanpa pengawasan:** `text` Kolom tunggal untuk analisis kepercayaan
## Siapkan lingkungan evaluasi Anda
Buat JupyterLab spasi di SageMaker Amazon SageMaker Studio untuk menjalankan notebook evaluasi.
1. Di Studio, pilih **JupyterLab**dari layar beranda.
1. Jika Anda tidak memiliki ruang:
1. Pilih **Buat ruang**.
1. Masukkan nama deskriptif (misalnya,**TextModelEvaluation)**.
1. Pertahankan jenis instance default.
1. Pilih **Jalankan ruang**.
1. Ketika ruang telah dibuat, pilih **Buka JupyterLab**.
### Akses buku catatan evaluasi
Unduh [file zip](samples/sagemaker-text-classification-evaluation-2.zip) dan ekstrak ke mesin lokal Anda. Unggah seluruh folder yang diekstraksi ke JupyterLab ruang Anda untuk mulai menguji model Anda. Paket ini berisi buku catatan evaluasi utama, kumpulan data sampel, modul Python pendukung, dan instruksi terperinci untuk kerangka evaluasi lengkap.
**catatan**
Setelah mengekstrak paket, tinjau file README untuk instruksi pengaturan terperinci dan ikhtisar kerangka kerja.
Terus [Tafsirkan hasil Anda](jumpstart-text-classification-interpret.md) belajar bagaimana menganalisis output evaluasi dan membuat keputusan pemilihan model berbasis data.
# Tafsirkan hasil Anda
Analisis metrik evaluasi dari perbandingan model klasifikasi teks Anda untuk membuat keputusan berbasis data untuk penerapan produksi.
## Memahami metrik evaluasi
Evaluasi menyediakan beberapa metrik utama untuk setiap model di semua kumpulan data:
### Akurasi
Mengukur persentase prediksi yang benar dan bekerja paling baik untuk kumpulan data yang seimbang. Namun, itu bisa menyesatkan dengan data yang tidak seimbang dan mungkin menunjukkan hasil artifial tinggi ketika satu kelas mendominasi.
### presisi
Mengevaluasi seberapa baik model menghindari positif palsu dengan mengukur berapa persentase prediksi positif yang benar. Metrik ini berkisar dari 0,0 hingga 1,0 (lebih tinggi lebih baik) dan menjadi kritis ketika positif palsu mahal.
### Ingat
Menilai seberapa baik model menangkap semua kasus positif dengan mengukur berapa persentase positif aktual yang ditemukan. Ini berkisar dari 0,0 hingga 1,0 (lebih tinggi lebih baik) dan menjadi kritis ketika kehilangan positif mahal.
### Skor F1
Memberikan rata-rata harmonik presisi dan ingatan, menyeimbangkan kedua metrik menjadi skor tunggal yang berkisar antara 0,0 hingga 1,0 (lebih tinggi lebih baik).
### Koefisien Korelasi Matthews (PKS)
Mengukur kualitas klasifikasi biner secara keseluruhan dan berfungsi sebagai metrik terbaik untuk data yang tidak seimbang. Ini berkisar dari -1.0 hingga 1.0, di mana nilai yang lebih tinggi menunjukkan kinerja yang lebih baik dan 0 mewakili tebakan acak.
### Area Di Bawah Karakteristik Operasi Penerima Kurva
Mengevaluasi seberapa baik model membedakan antara kelas. Ini berkisar dari 0,0 hingga 1,0, di mana 1,0 mewakili klasifikasi sempurna dan 0,5 mewakili tebakan acak.
### Waktu inferensi rata-rata
Mengukur kecepatan prediksi, yang menjadi penting untuk aplikasi real-time. Pertimbangkan kecepatan dan konsistensi saat mengevaluasi metrik ini.
**catatan**
Jangan hanya mengandalkan akurasi untuk pemilihan model. Untuk kumpulan data yang tidak seimbang, presisi, penarikan, dan PKS memberikan indikator kinerja dunia nyata yang lebih andal.
## Bandingkan kinerja di seluruh jenis kumpulan data
**Dataset seimbang** menunjukkan seberapa baik kinerja model Anda dalam kondisi ideal dengan representasi yang sama dari contoh positif dan negatif. Kinerja yang kuat di sini menunjukkan model telah mempelajari pola klasifikasi teks dasar.
**Dataset miring** mengungkapkan bagaimana model menangani ketidakseimbangan kelas dunia nyata, yang umum dalam skenario produksi.
**Kumpulan data yang menantang** menguji ketahanan model pada kasus ambigu atau tepi yang mungkin muncul dalam produksi.
## Pemilihan model
Gunakan pendekatan sistematis ini untuk memilih model optimal untuk kasus penggunaan spesifik Anda.
### Tentukan prioritas bisnis Anda
Sebelum memilih model, tentukan faktor kinerja mana yang paling penting untuk kasus penggunaan Anda.
1. Identifikasi persyaratan akurasi Anda dan ambang batas kinerja minimum yang dapat diterima.
1. Tentukan batasan latensi Anda, termasuk apakah Anda memerlukan pemrosesan real-time (<100ms) atau batch.
1. Tetapkan pertimbangan biaya dan anggaran Anda untuk inferensi dan penskalaan.
1. Analisis karakteristik data Anda untuk memahami apakah data produksi Anda seimbang, miring, atau sangat bervariasi.
### Kapan memilih setiap model
Berdasarkan hasil evaluasi Anda, pilih model yang paling sesuai dengan kasus penggunaan Anda:
+ **Pilih DistiLbert** ketika Anda membutuhkan inferensi yang lebih cepat dengan akurasi yang baik, seperti analisis sentimen waktu nyata dalam chatbot layanan pelanggan, sistem moderasi konten, atau aplikasi di mana waktu respons di bawah 100 md sangat penting.
+ **Pilih BERT** ketika akurasi maksimum lebih penting daripada kecepatan, seperti klasifikasi dokumen hukum, analisis teks medis, atau aplikasi kepatuhan di mana presisi adalah yang terpenting dan pemrosesan batch dapat diterima.
### Prioritaskan kumpulan data evaluasi Anda
Fokus pada kumpulan data yang paling mewakili kasus penggunaan dunia nyata Anda.
1. Berikan bobot lebih pada kumpulan data yang paling mirip dengan data dunia nyata Anda.
1. Pertimbangkan pentingnya kasus tepi dalam aplikasi Anda dan prioritaskan kinerja kumpulan data yang menantang.
1. Seimbangkan optimasi di beberapa skenario daripada berfokus hanya pada satu jenis kumpulan data.
Bandingkan hasil evaluasi Anda dengan prioritas ini untuk memilih model yang paling menyeimbangkan akurasi, kecepatan, dan persyaratan biaya Anda.
Sekarang setelah Anda memilih model pilihan Anda, Anda siap untuk penerapan produksi. Lanjutkan ke [Terapkan model Anda dalam skala besar](jumpstart-text-classification-scale.md).
# Terapkan model Anda dalam skala besar
Siapkan auto-scaling CloudWatch dan monitoring untuk titik akhir AI SageMaker Anda agar siap produksi.
## Mengapa pemantauan produksi penting untuk klasifikasi teks
Beban kerja klasifikasi teks memerlukan pemantauan karena:
+ Rasakan pola lalu lintas variabel dengan ledakan pemrosesan.
+ Membutuhkan waktu respons sub-detik.
+ Perlu pengoptimalan biaya melalui auto-scaling.
## Prasyarat
Sebelum Anda mulai, pastikan Anda memiliki:
+ Titik akhir SageMaker AI Anda diterapkan dari bagian sebelumnya.
+ Nama titik akhir Anda (misalnya, jumpstart-dft-hf-tc).
+ Anda Wilayah AWS (misalnya, us-east-2).
[Untuk pembuatan atau pemecahan masalah titik akhir, lihat Inferensi waktu nyata.](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints.html)
## Mengatur pemantauan produksi
Konfigurasikan CloudWatch pemantauan untuk melacak kinerja model Anda dalam produksi.
1. Di JupyterLab ruang Anda, buka `sagemaker_production_monitoring.ipynb` buku catatan dari paket evaluasi yang Anda unggah sebelumnya.
1. Perbarui nama dan wilayah titik akhir Anda di bagian konfigurasi.
1. Ikuti instruksi buku catatan untuk mengatur:
+ Penskalaan otomatis (1-10 instance berdasarkan lalu lintas).
+ CloudWatch alarm untuk ambang batas latensi dan pemanggilan.
+ Dasbor metrik untuk pemantauan visual.
## Verifikasi pengaturan Anda
Setelah Anda menyelesaikan langkah-langkah buku catatan, verifikasi bahwa Anda memiliki:
+ **Status Titik Akhir**:`InService`.
+ **Penskalaan otomatis**: 1-10 instance dikonfigurasi.
+ **CloudWatch Alarm**: 2 alarm pemantauan.
+ **Metrik**: 15\$1 metrik terdaftar.
**catatan**
Alarm mungkin muncul `INSUFFICIENT_DATA` pada awalnya - ini normal dan akan berubah `OK` dengan penggunaan.
## Pantau titik akhir Anda
Akses pemantauan visual melalui Konsol AWS Manajemen:
+ [CloudWatch Metrik-metrik](https://console.aws.amazon.com/cloudwatch/home#metricsV2:graph=~();query=AWS/SageMaker)
+ [CloudWatch Alarm](https://console.aws.amazon.com/cloudwatch/home#alarmsV2:)
Untuk informasi lebih lanjut, lihat [Monitor SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-overview.html).
## Mengelola biaya dan membersihkan sumber daya
Pengaturan pemantauan Anda memberikan wawasan produksi yang berharga, tetapi juga menimbulkan AWS biaya berkelanjutan melalui CloudWatch metrik, alarm, dan kebijakan auto-scaling. Memahami cara mengelola biaya ini sangat penting untuk operasi yang hemat biaya. Bersihkan sumber daya ketika mereka tidak lagi dibutuhkan.
**Awas**
Titik akhir Anda terus dikenakan biaya bahkan saat tidak memproses permintaan. Untuk menghentikan semua tagihan, Anda harus menghapus titik akhir Anda. Untuk petunjuk, lihat [Menghapus Titik Akhir dan Sumber Daya](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-delete-resources.html).
Untuk konfigurasi pemantauan lanjutan, lihat [CloudWatch Metrik untuk SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html).
# Keadilan, penjelasan model, dan deteksi bias dengan Clarify SageMaker
Anda dapat menggunakan Amazon SageMaker Clarify untuk memahami keadilan dan penjelasan model serta untuk menjelaskan dan mendeteksi bias dalam model Anda. Anda dapat mengonfigurasi tugas pemrosesan SageMaker Clarify untuk menghitung metrik bias dan atribusi fitur serta menghasilkan laporan untuk penjelasan model. SageMaker Pekerjaan pemrosesan klarifikasi diimplementasikan menggunakan gambar kontainer SageMaker Clarify khusus. Halaman berikut SageMaker menjelaskan cara kerja Clarify dan cara memulai analisis.
## Apa keadilan dan penjelasan model untuk prediksi pembelajaran mesin?
Model pembelajaran mesin (ML) membantu membuat keputusan dalam domain termasuk layanan keuangan, perawatan kesehatan, pendidikan, dan sumber daya manusia. Pembuat kebijakan, regulator, dan advokat telah meningkatkan kesadaran tentang tantangan etika dan kebijakan yang ditimbulkan oleh ML dan sistem berbasis data. Amazon SageMaker Clarify dapat membantu Anda memahami mengapa model ML Anda membuat prediksi tertentu dan apakah bias ini memengaruhi prediksi ini selama pelatihan atau inferensi. SageMaker Clarify juga menyediakan alat yang dapat membantu Anda membangun model pembelajaran mesin yang kurang bias dan lebih mudah dipahami. SageMaker Clarify juga dapat menghasilkan laporan tata kelola model yang dapat Anda berikan kepada tim risiko dan kepatuhan serta regulator eksternal. Dengan SageMaker Clarify, Anda dapat melakukan hal berikut:
+ Deteksi bias dan bantu jelaskan prediksi model Anda.
+ Identifikasi jenis bias dalam data pra-pelatihan.
+ Identifikasi jenis bias dalam data pasca-pelatihan yang dapat muncul selama pelatihan atau saat model Anda sedang diproduksi.
SageMaker Clarify membantu menjelaskan bagaimana model Anda membuat prediksi menggunakan atribusi fitur. Ini juga dapat memantau model inferensi yang sedang diproduksi untuk bias dan penyimpangan atribusi fitur. Informasi ini dapat membantu Anda dalam bidang-bidang berikut:
+ **Regulasi** — Pembuat kebijakan dan regulator lainnya dapat memiliki kekhawatiran tentang dampak diskriminatif dari keputusan yang menggunakan output dari model ML. Misalnya, model ML dapat mengkodekan bias dan mempengaruhi keputusan otomatis.
+ **Bisnis** — Domain yang diatur mungkin memerlukan penjelasan yang dapat diandalkan tentang bagaimana model ML membuat prediksi. Penjelasan model mungkin sangat penting bagi industri yang bergantung pada keandalan, keamanan, dan kepatuhan. Ini dapat mencakup layanan keuangan, sumber daya manusia, perawatan kesehatan, dan transportasi otomatis. Misalnya, aplikasi pinjaman mungkin perlu memberikan penjelasan tentang bagaimana model ML membuat prediksi tertentu kepada petugas pinjaman, peramal, dan pelanggan.
+ **Ilmu Data** — Ilmuwan data dan insinyur ML dapat men-debug dan meningkatkan model ML ketika mereka dapat menentukan apakah suatu model membuat kesimpulan berdasarkan fitur yang bising atau tidak relevan. Mereka juga dapat memahami keterbatasan model dan mode kegagalan yang mungkin dihadapi model mereka.
Untuk posting blog yang menunjukkan cara merancang dan membangun model pembelajaran mesin lengkap untuk klaim mobil palsu yang mengintegrasikan SageMaker Clarify ke dalam pipa SageMaker AI, lihat [Arsitek dan bangun siklus hidup pembelajaran mesin lengkap dengan: AWS](https://aws.amazon.com/blogs/machine-learning/architect-and-build-the-full-machine-learning-lifecycle-with-amazon-sagemaker/) Demo Amazon AI. end-to-end SageMaker Posting blog ini membahas cara menilai dan mengurangi bias pra-pelatihan dan pasca-pelatihan, dan bagaimana fitur memengaruhi prediksi model. Posting blog berisi tautan ke kode contoh untuk setiap tugas dalam siklus hidup ML.
### Praktik terbaik untuk mengevaluasi keadilan dan penjelasan dalam siklus hidup ML
**Keadilan sebagai proses** — Gagasan bias dan keadilan tergantung pada penerapannya. Pengukuran bias dan pilihan metrik bias dapat dipandu oleh pertimbangan sosial, hukum, dan non-teknis lainnya. Keberhasilan adopsi pendekatan ML yang sadar keadilan termasuk membangun konsensus dan mencapai kolaborasi di seluruh pemangku kepentingan utama. Ini mungkin termasuk produk, kebijakan, hukum, teknik, AI/ML tim, pengguna akhir, dan komunitas.
**Keadilan dan keterjelasannya berdasarkan desain dalam siklus hidup ML — Pertimbangkan keadilan dan penjelasan selama setiap tahap siklus hidup** ML. Tahapan ini meliputi pembentukan masalah, konstruksi dataset, pemilihan algoritma, proses pelatihan model, proses pengujian, penyebaran, dan pemantauan dan umpan balik. Penting untuk memiliki alat yang tepat untuk melakukan analisis ini. Sebaiknya ajukan pertanyaan-pertanyaan berikut selama siklus hidup ML:
+ Apakah model mendorong loop umpan balik yang dapat menghasilkan hasil yang semakin tidak adil?
+ Apakah algoritma merupakan solusi etis untuk masalah tersebut?
+ Apakah data pelatihan mewakili kelompok yang berbeda?
+ Apakah ada bias dalam label atau fitur?
+ Apakah data perlu dimodifikasi untuk mengurangi bias?
+ Apakah kendala keadilan perlu dimasukkan dalam fungsi objektif?
+ Apakah model telah dievaluasi menggunakan metrik keadilan yang relevan?
+ Apakah ada efek yang tidak setara di seluruh pengguna?
+ Apakah model tersebut digunakan pada populasi yang tidak dilatih atau dievaluasi?
![\[Praktik terbaik untuk proses mengevaluasi keadilan dan penjelasan model.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/clarify-best-practices-image.png)
### Panduan untuk penjelasan SageMaker AI dan dokumentasi bias
Bias dapat terjadi dan diukur dalam data baik sebelum dan sesudah melatih model. SageMaker Clarify dapat memberikan penjelasan untuk prediksi model setelah pelatihan dan untuk model yang digunakan untuk produksi. SageMaker Clarify juga dapat memantau model dalam produksi untuk setiap penyimpangan dalam atribusi penjelasan dasar mereka, dan menghitung garis dasar bila diperlukan. Dokumentasi untuk menjelaskan dan mendeteksi bias menggunakan SageMaker Clarify disusun sebagai berikut:
+ Untuk informasi tentang menyiapkan pekerjaan pemrosesan untuk bias dan penjelasan, lihat. [Konfigurasikan SageMaker Clarify Processing Job](clarify-processing-job-configure-parameters.md)
+ Untuk informasi tentang mendeteksi bias dalam data pra-pemrosesan sebelum digunakan untuk melatih model, lihat. [Bias Data Pra-pelatihan](clarify-detect-data-bias.md)
+ Untuk informasi tentang mendeteksi data pasca-pelatihan dan bias model, lihat. [Data Pasca Pelatihan dan Bias Model](clarify-detect-post-training-bias.md)
+ Untuk informasi tentang pendekatan atribusi fitur model-agnostik untuk menjelaskan prediksi model setelah pelatihan, lihat. [Penjelasan Model](clarify-model-explainability.md)
+ Untuk informasi tentang pemantauan kontribusi fitur yang menjauh dari baseline yang ditetapkan selama pelatihan model, lihat. [Penyimpangan atribusi fitur untuk model dalam produksi](clarify-model-monitor-feature-attribution-drift.md)
+ Untuk informasi tentang model pemantauan yang sedang diproduksi untuk penyimpangan dasar, lihat. [Bias drift untuk model dalam produksi](clarify-model-monitor-bias-drift.md)
+ Untuk informasi tentang mendapatkan penjelasan secara real time dari titik akhir SageMaker AI, lihat. [Penjelasan online dengan Clarify SageMaker](clarify-online-explainability.md)
## Bagaimana SageMaker Memperjelas Pekerjaan Pemrosesan Pekerjaan
Anda dapat menggunakan SageMaker Clarify untuk menganalisis kumpulan data dan model Anda untuk menjelaskan dan bias. Pekerjaan pemrosesan SageMaker Clarify menggunakan container pemrosesan SageMaker Clarify untuk berinteraksi dengan bucket Amazon S3 yang berisi kumpulan data input Anda. Anda juga dapat menggunakan SageMaker Clarify untuk menganalisis model pelanggan yang diterapkan ke titik akhir inferensi SageMaker AI.
Grafik berikut menunjukkan bagaimana pekerjaan pemrosesan SageMaker Clarify berinteraksi dengan data input Anda dan secara opsional, dengan model pelanggan. Interaksi ini tergantung pada jenis analisis spesifik yang dilakukan. Container pemrosesan SageMaker Clarify memperoleh dataset input dan konfigurasi untuk analisis dari bucket S3. Untuk jenis analisis tertentu, termasuk analisis fitur, wadah pemrosesan SageMaker Clarify harus mengirim permintaan ke wadah model. Kemudian mengambil prediksi model dari respons yang dikirim oleh wadah model. Setelah itu, wadah pemrosesan SageMaker Clarify menghitung dan menyimpan hasil analisis ke bucket S3.
![\[SageMaker Clarify dapat menganalisis data Anda atau model pelanggan untuk penjelasan dan bias.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/clarify/clarify-processing-job.png)
Anda dapat menjalankan tugas pemrosesan SageMaker Clarify pada beberapa tahap dalam siklus hidup alur kerja pembelajaran mesin. SageMaker Clarify dapat membantu Anda menghitung jenis analisis berikut:
+ Metrik bias pra-pelatihan. Metrik ini dapat membantu Anda memahami bias dalam data Anda sehingga Anda dapat mengatasinya dan melatih model Anda pada kumpulan data yang lebih adil. Lihat [Metrik Bias Pra-pelatihan](clarify-measure-data-bias.md) untuk informasi tentang metrik bias pra-pelatihan. Untuk menjalankan pekerjaan menganalisis metrik bias pra-pelatihan, Anda harus menyediakan kumpulan data dan file konfigurasi analisis JSON. [File Konfigurasi Analisis](clarify-processing-job-configure-analysis.md)
+ Metrik bias pasca-pelatihan. Metrik ini dapat membantu Anda memahami bias apa pun yang diperkenalkan oleh algoritme, pilihan hiperparameter, atau bias apa pun yang tidak terlihat sebelumnya dalam aliran. Untuk informasi lebih lanjut tentang metrik bias pasca-pelatihan, lihat. [Data Pasca-pelatihan dan Metrik Bias Model](clarify-measure-post-training-bias.md) SageMaker Clarify menggunakan prediksi model selain data dan label untuk mengidentifikasi bias. Untuk menjalankan pekerjaan menganalisis metrik bias pasca-pelatihan, Anda harus menyediakan kumpulan data dan file konfigurasi analisis JSON. Konfigurasi harus menyertakan model atau nama titik akhir.
+ Nilai Shapley, yang dapat membantu Anda memahami dampak fitur Anda terhadap prediksi model Anda. Untuk informasi lebih lanjut tentang nilai-nilai Shapley, lihat. [Atribusi Fitur yang Menggunakan Nilai Shapley](clarify-shapley-values.md) Fitur ini membutuhkan model yang terlatih.
+ Plot ketergantungan parsi (PDPs), yang dapat membantu Anda memahami seberapa besar variabel target prediksi Anda akan berubah jika Anda memvariasikan nilai satu fitur. Untuk informasi selengkapnya PDPs, lihat Fitur [Analisis plot ketergantungan sebagian (PDPs)](clarify-processing-job-analysis-results.md#clarify-processing-job-analysis-results-pdp) ini memerlukan model terlatih.
SageMaker Klarifikasi prediksi model kebutuhan untuk menghitung metrik bias pasca-pelatihan dan atribusi fitur. *Anda dapat memberikan endpoint atau SageMaker Clarify akan membuat endpoint sementara menggunakan nama model Anda, juga dikenal sebagai titik akhir bayangan.* Container SageMaker Clarify menghapus titik akhir bayangan setelah perhitungan selesai. Pada tingkat tinggi, wadah SageMaker Clarify menyelesaikan langkah-langkah berikut:
1. Memvalidasi input dan parameter.
1. Menciptakan titik akhir bayangan (jika nama model disediakan).
1. Memuat dataset input ke dalam bingkai data.
1. Memperoleh prediksi model dari titik akhir, jika perlu.
1. Menghitung metrik bias dan fitur atribusi.
1. Menghapus titik akhir bayangan.
1. Hasilkan hasil analisis.
Setelah pekerjaan pemrosesan SageMaker Clarify selesai, hasil analisis akan disimpan di lokasi keluaran yang Anda tentukan dalam parameter keluaran pemrosesan pekerjaan. Hasil ini mencakup file JSON dengan metrik bias dan atribusi fitur global, laporan visual, dan file tambahan untuk atribusi fitur lokal. Anda dapat mengunduh hasil dari lokasi output dan melihatnya.
Untuk informasi tambahan tentang metrik bias, penjelasan, dan cara menafsirkannya, lihat Pelajari [Bagaimana Amazon SageMaker Clarify Membantu Mendeteksi Bias](https://aws.amazon.com/blogs/machine-learning/learn-how-amazon-sagemaker-clarify-helps-detect-bias), Pengukuran [Keadilan untuk Machine Learning in Finance, dan Whitepaper [Amazon AI](https://pages.awscloud.com/rs/112-TZM-766/images/Amazon.AI.Fairness.and.Explainability.Whitepaper.pdf) Fairness](https://pages.awscloud.com/rs/112-TZM-766/images/Fairness.Measures.for.Machine.Learning.in.Finance.pdf) and Explainability.
# Konfigurasikan SageMaker Clarify Processing Job
Untuk menganalisis data dan model Anda untuk bias dan penjelasan menggunakan SageMaker Clarify, Anda harus mengonfigurasi pekerjaan pemrosesan SageMaker Clarify. Panduan ini menunjukkan cara menentukan nama dataset input, nama file konfigurasi analisis, dan lokasi keluaran untuk pekerjaan pemrosesan. Untuk mengkonfigurasi wadah pemrosesan, input pekerjaan, output, sumber daya, dan parameter lainnya, Anda memiliki dua opsi. Anda dapat menggunakan SageMaker AI `CreateProcessingJob` API, atau menggunakan SageMaker AI Python SDK API, `SageMaker ClarifyProcessor`
Untuk informasi tentang parameter yang umum untuk semua pekerjaan pemrosesan, lihat [Referensi SageMaker API Amazon](https://docs.aws.amazon.com/sagemaker/latest/APIReference/Welcome.html?icmpid=docs_sagemaker_lp).
## Mengonfigurasi tugas pemrosesan SageMaker Clarify menggunakan SageMaker API
Petunjuk berikut menunjukkan cara menyediakan setiap bagian dari konfigurasi spesifik SageMaker Clarify menggunakan `CreateProcessingJob` API.
1. Masukkan pengidentifikasi penelitian seragam (URI) dari gambar kontainer SageMaker Clarify di dalam `AppSpecification` parameter, seperti yang ditunjukkan pada contoh kode berikut.
```
{
"ImageUri": "the-clarify-container-image-uri"
}
```
**catatan**
URI harus mengidentifikasi image kontainer SageMaker Clarify yang sudah dibuat sebelumnya. `ContainerEntrypoint`dan `ContainerArguments` tidak didukung. Untuk informasi selengkapnya tentang SageMaker Clarify gambar kontainer, lihat[Kontainer SageMaker Klarifikasi Prebuilt](clarify-processing-job-configure-container.md).
1. Tentukan konfigurasi untuk analisis dan parameter untuk kumpulan data input Anda di dalam `ProcessingInputs` parameter.
1. Tentukan lokasi file konfigurasi analisis JSON, yang mencakup parameter untuk analisis bias dan analisis penjelasan. `InputName`Parameter `ProcessingInput` objek harus **analysis\$1config** seperti yang ditunjukkan pada contoh kode berikut.
```
{
"InputName": "analysis_config",
"S3Input": {
"S3Uri": "s3://your-bucket/analysis_config.json",
"S3DataType": "S3Prefix",
"S3InputMode": "File",
"LocalPath": "/opt/ml/processing/input/config"
}
}
```
Untuk informasi selengkapnya tentang skema file konfigurasi analisis, lihat[File Konfigurasi Analisis](clarify-processing-job-configure-analysis.md).
1. Tentukan lokasi dataset input. `InputName`Parameter `ProcessingInput` objek harus`dataset`. Parameter ini opsional jika Anda telah menyediakan “dataset\$1uri” dalam file konfigurasi analisis. Nilai-nilai berikut diperlukan dalam `S3Input` konfigurasi.
1. `S3Uri`dapat berupa objek Amazon S3 atau awalan S3.
1. `S3InputMode`harus dari tipe**File**.
1. `S3CompressionType`harus bertipe `None` (nilai default).
1. `S3DataDistributionType`harus bertipe `FullyReplicated` (nilai default).
1. `S3DataType`bisa salah satu `S3Prefix` atau`ManifestFile`. Untuk menggunakan`ManifestFile`, `S3Uri` parameter harus menentukan lokasi file manifes yang mengikuti skema dari bagian Referensi SageMaker API [S3Uri](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html#sagemaker-Type-S3DataSource-S3Uri). File manifes ini harus mencantumkan objek S3 yang berisi data input untuk pekerjaan tersebut.
Kode berikut menunjukkan contoh konfigurasi input.
```
{
"InputName": "dataset",
"S3Input": {
"S3Uri": "s3://your-bucket/your-dataset.csv",
"S3DataType": "S3Prefix",
"S3InputMode": "File",
"LocalPath": "/opt/ml/processing/input/data"
}
}
```
1. Tentukan konfigurasi untuk output dari pekerjaan pemrosesan di dalam `ProcessingOutputConfig` parameter. Satu `ProcessingOutput` objek diperlukan dalam `Outputs` konfigurasi. Berikut ini diperlukan dari konfigurasi output:
1. `OutputName`harus**analysis\$1result**.
1. `S3Uri`harus menjadi awalan S3 ke lokasi output.
1. `S3UploadMode` harus diatur ke **EndOfJob**.
Kode berikut menunjukkan contoh konfigurasi output.
```
{
"Outputs": [{
"OutputName": "analysis_result",
"S3Output": {
"S3Uri": "s3://your-bucket/result/",
"S3UploadMode": "EndOfJob",
"LocalPath": "/opt/ml/processing/output"
}
}]
}
```
1. Tentukan konfigurasi `ClusterConfig` untuk sumber daya yang Anda gunakan dalam pekerjaan pemrosesan Anda di dalam `ProcessingResources` parameter. Parameter berikut diperlukan di dalam `ClusterConfig` objek.
1. `InstanceCount`menentukan jumlah instance komputasi di cluster yang menjalankan pekerjaan pemrosesan. Tentukan nilai yang lebih besar dari `1` untuk mengaktifkan pemrosesan terdistribusi.
1. `InstanceType`mengacu pada sumber daya yang menjalankan pekerjaan pemrosesan Anda. Karena analisis SageMaker AI SHAP intensif komputasi, menggunakan jenis instance yang dioptimalkan untuk komputasi harus meningkatkan runtime untuk analisis. Pekerjaan pemrosesan SageMaker Clarify tidak digunakan GPUs.
Kode berikut menunjukkan contoh konfigurasi sumber daya.
```
{
"ClusterConfig": {
"InstanceCount": 1,
"InstanceType": "ml.m5.xlarge",
"VolumeSizeInGB": 20
}
}
```
1. Tentukan konfigurasi jaringan yang Anda gunakan dalam pekerjaan pemrosesan Anda di dalam `NetworkConfig` objek. Nilai-nilai berikut diperlukan dalam konfigurasi.
1. `EnableNetworkIsolation`harus disetel ke `False` (default) sehingga SageMaker Clarify dapat memanggil titik akhir, jika perlu, untuk prediksi.
1. Jika model atau titik akhir yang Anda berikan ke pekerjaan SageMaker Clarify berada dalam Amazon Virtual Private Cloud (Amazon VPC), maka pekerjaan SageMaker Clarify juga harus dalam VPC yang sama. Tentukan VPC menggunakan. [VpcConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_VpcConfig.html) Selain itu, VPC harus memiliki titik akhir ke bucket Amazon S3, layanan SageMaker AI, dan layanan AI Runtime. SageMaker
Jika pemrosesan terdistribusi diaktifkan, Anda juga harus mengizinkan komunikasi antara instance yang berbeda dalam pekerjaan pemrosesan yang sama. Konfigurasikan aturan untuk grup keamanan Anda yang memungkinkan koneksi masuk antara anggota grup keamanan yang sama. Untuk informasi selengkapnya, lihat [Berikan Amazon SageMaker Clarify Lowongan Akses ke Sumber Daya di Amazon VPC Anda](clarify-vpc.md).
Kode berikut memberikan contoh konfigurasi jaringan.
```
{
"EnableNetworkIsolation": False,
"VpcConfig": {
...
}
}
```
1. Atur waktu maksimum pekerjaan akan berjalan menggunakan `StoppingCondition` parameter. Waktu terpanjang yang dapat dijalankan oleh pekerjaan SageMaker Clarify adalah `7` berhari-hari atau `604800` detik. Jika pekerjaan tidak dapat diselesaikan dalam batas waktu ini, itu akan dihentikan dan tidak ada hasil analisis yang akan diberikan. Sebagai contoh, konfigurasi berikut membatasi waktu maksimum pekerjaan dapat berjalan hingga 3600 detik.
```
{
"MaxRuntimeInSeconds": 3600
}
```
1. Tentukan peran IAM untuk `RoleArn` parameter. Peran tersebut harus memiliki hubungan kepercayaan dengan Amazon SageMaker AI. Ini dapat digunakan untuk melakukan operasi SageMaker API yang tercantum dalam tabel berikut. Sebaiknya gunakan kebijakan terkelola Amazon SageMaker AIFull Access, yang memberikan akses penuh ke SageMaker AI. Untuk informasi lebih lanjut tentang kebijakan ini, lihat[AWS kebijakan terkelola: AmazonSageMakerFullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonSageMakerFullAccess). Jika Anda memiliki kekhawatiran tentang pemberian akses penuh, izin minimal yang diperlukan bergantung pada apakah Anda memberikan model atau nama titik akhir. Menggunakan nama titik akhir memungkinkan pemberian lebih sedikit izin ke AI. SageMaker
Tabel berikut berisi operasi API yang digunakan oleh tugas pemrosesan SageMaker Clarify. **X**Di bawah **Nama Model dan nama** **Endpoint** mencatat operasi API yang diperlukan untuk setiap input.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/clarify-processing-job-configure-parameters.html)
Untuk informasi lebih lanjut tentang izin yang diperlukan, lihat [Izin Amazon SageMaker AI API: Tindakan, Izin, dan Referensi Sumber Daya](api-permissions-reference.md).
Untuk informasi lebih lanjut tentang meneruskan peran ke SageMaker AI, lihat[Peran Lulus](sagemaker-roles.md#sagemaker-roles-pass-role).
Setelah Anda memiliki masing-masing bagian dari konfigurasi pekerjaan pemrosesan, gabungkan mereka untuk mengonfigurasi pekerjaan.
## Konfigurasikan pekerjaan pemrosesan SageMaker Clarify menggunakan AWS SDK untuk Python
Contoh kode berikut menunjukkan cara meluncurkan pekerjaan pemrosesan SageMaker Clarify menggunakan [AWS SDK untuk Python](https://aws.amazon.com/sdk-for-python/).
```
sagemaker_client.create_processing_job(
ProcessingJobName="your-clarify-job-name",
AppSpecification={
"ImageUri": "the-clarify-container-image-uri",
},
ProcessingInputs=[{
"InputName": "analysis_config",
"S3Input": {
"S3Uri": "s3://your-bucket/analysis_config.json",
"S3DataType": "S3Prefix",
"S3InputMode": "File",
"LocalPath": "/opt/ml/processing/input/config",
},
}, {
"InputName": "dataset",
"S3Input": {
"S3Uri": "s3://your-bucket/your-dataset.csv",
"S3DataType": "S3Prefix",
"S3InputMode": "File",
"LocalPath": "/opt/ml/processing/input/data",
},
},
],
ProcessingOutputConfig={
"Outputs": [{
"OutputName": "analysis_result",
"S3Output": {
"S3Uri": "s3://your-bucket/result/",
"S3UploadMode": "EndOfJob",
"LocalPath": "/opt/ml/processing/output",
},
}],
},
ProcessingResources={
"ClusterConfig": {
"InstanceCount": 1,
"InstanceType": "ml.m5.xlarge",
"VolumeSizeInGB": 20,
},
},
NetworkConfig={
"EnableNetworkIsolation": False,
"VpcConfig": {
...
},
},
StoppingCondition={
"MaxRuntimeInSeconds": 3600,
},
RoleArn="arn:aws:iam:::role/service-role/AmazonSageMaker-ExecutionRole",
)
```
Untuk contoh buku catatan dengan instruksi untuk menjalankan tugas pemrosesan SageMaker Clarify menggunakan AWS SDK untuk Python, [lihat Keadilan dan Keterjelasan dengan SageMaker Clarify](http://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-clarify/fairness_and_explainability/fairness_and_explainability_boto3.ipynb) using SDK for Python. AWS Bucket S3 apa pun yang digunakan di notebook harus berada di AWS Region yang sama dengan instance notebook yang mengaksesnya.
## Konfigurasikan pekerjaan pemrosesan SageMaker Clarify menggunakan SageMaker Python SDK
Anda juga dapat mengonfigurasi pekerjaan pemrosesan SageMaker Clarify menggunakan [SageMaker ClarifyProcessor](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html#sagemaker.clarify.SageMakerClarifyProcessor)API SDK SageMaker Python. Untuk informasi selengkapnya, lihat [Jalankan Pekerjaan Pemrosesan SageMaker Klarifikasi untuk Analisis Bias dan Penjelasan](clarify-processing-job-run.md).
**Topics**
+ [Kontainer SageMaker Klarifikasi Prebuilt](clarify-processing-job-configure-container.md)
+ [File Konfigurasi Analisis](clarify-processing-job-configure-analysis.md)
+ [Panduan Kompatibilitas Format Data](clarify-processing-job-data-format.md)
# Kontainer SageMaker Klarifikasi Prebuilt
Amazon SageMaker AI menyediakan gambar kontainer SageMaker Clarify bawaan yang menyertakan pustaka dan dependensi lain yang diperlukan untuk menghitung metrik bias dan atribusi fitur untuk penjelasan. Gambar-gambar ini mampu menjalankan [pekerjaan pemrosesan SageMaker Clarify](processing-job.md) di akun Anda.
Gambar URIs untuk wadah dalam bentuk berikut:
```
.dkr.ecr..amazonaws.com/sagemaker-clarify-processing:1.0
```
Contoh:
```
111122223333.dkr.ecr.us-east-1.amazonaws.com/sagemaker-clarify-processing:1.0
```
Tabel berikut mencantumkan alamat oleh Wilayah AWS.
Gambar Docker untuk Pekerjaan Pemrosesan SageMaker Klarifikasi
| Region | Alamat gambar |
| --- | --- |
| AS Timur (Virginia Utara) | 205585389593.dkr. ecr.us-east-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| AS Timur (Ohio) | 211330385671.dkr. ecr.us-east-2.amazonaws.com /:1.0 sagemaker-clarify-processing |
| AS Barat (California Utara) | 740489534195.dkr. ecr.us-west-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| AS Barat (Oregon) | 306415355426.dkr. ecr.us-west-2.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Asia Pasifik (Hong Kong) | 098760798382.dkr. ecr.ap-east-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Asia Pasifik (Mumbai) | 452307495513.dkr. ecr.ap-south-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Asia Pasifik (Jakarta) | 705930551576.dkr. ecr.ap-southeast-3.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Asia Pasifik (Tokyo) | 377024640650.dkr. ecr.ap-northeast-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Asia Pasifik (Seoul) | 263625296855.dkr. ecr.ap-northeast-2.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Asia Pasifik (Osaka) | 912233562940.dkr. ecr.ap-northeast-3.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Asia Pasifik (Singapura) | 834264404009.dkr. ecr.ap-southeast-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Asia Pasifik (Sydney) | 007051062584.dkr. ecr.ap-southeast-2.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Kanada (Pusat) | 675030665977.dkr. ecr.ca-central-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Eropa (Frankfurt) | 017069133835.dkr. ecr.eu-central-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Europe (Zurich) | 730335477804.dkr. ecr.eu-central-2.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Eropa (Irlandia) | 131013547314.dkr. ecr.eu-west-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Eropa (London) | 440796970383.dkr. ecr.eu-west-2.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Eropa (Paris) | 341593696636.dkr. ecr.eu-west-3.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Eropa (Stockholm) | 763603941244.dkr. ecr.eu-north-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Timur Tengah (Bahrain) | 835444307964.dkr. ecr.me-south-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Amerika Selatan (Sao Paulo) | 520018980103.dkr. ecr.sa-east-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Africa (Cape Town) | 811711786498.dkr. ecr.af-south-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Europe (Milan) | 638885417683.dkr. ecr.eu-south-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Tiongkok (Beijing) | 122526803553.dkr. ecr.cn-north-1.amazonaws.com .cn/:1.0 sagemaker-clarify-processing |
| Tiongkok (Ningxia) | 122578899357.dkr. ecr.cn-northwest-1.amazonaws.com .cn/:1.0 sagemaker-clarify-processing |
# File Konfigurasi Analisis
Untuk menganalisis data dan model Anda untuk menjelaskan dan bias menggunakan SageMaker Clarify, Anda harus mengonfigurasi pekerjaan pemrosesan. Bagian dari konfigurasi untuk pekerjaan pemrosesan ini mencakup konfigurasi file analisis. File analisis menentukan parameter untuk analisis bias dan penjelasan. Lihat [Konfigurasikan SageMaker Clarify Processing Job](clarify-processing-job-configure-parameters.md) untuk mempelajari cara mengonfigurasi pekerjaan pemrosesan dan file analisis.
Panduan ini menjelaskan skema dan parameter untuk file konfigurasi analisis ini. Panduan ini juga mencakup contoh file konfigurasi analisis untuk metrik bias komputasi untuk kumpulan data tabel, dan menghasilkan penjelasan untuk masalah pemrosesan bahasa alami (NLP), visi komputer (CV), dan deret waktu (TS).
Anda dapat membuat file konfigurasi analisis atau menggunakan [SageMaker Python SDK](https://sagemaker.readthedocs.io/) untuk menghasilkan satu untuk Anda dengan API. [SageMaker ClarifyProcessor](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html#sagemaker.clarify.SageMakerClarifyProcessor) Melihat isi file dapat membantu untuk memahami konfigurasi dasar yang digunakan oleh tugas SageMaker Clarify.
**Topics**
+ [Skema untuk file konfigurasi analisis](#clarify-processing-job-configure-schema)
+ [Contoh file konfigurasi analisis](#clarify-processing-job-configure-analysis-examples)
## Skema untuk file konfigurasi analisis
Bagian berikut menjelaskan skema untuk file konfigurasi analisis termasuk persyaratan dan deskripsi parameter.
### Persyaratan untuk file konfigurasi analisis
Pekerjaan pemrosesan SageMaker Clarify mengharapkan file konfigurasi analisis terstruktur dengan persyaratan berikut:
+ Nama input pemrosesan harus `analysis_config.`
+ File konfigurasi analisis dalam format JSON, dan dikodekan dalam UTF-8.
+ File konfigurasi analisis adalah objek Amazon S3.
Anda dapat menentukan parameter tambahan dalam file konfigurasi analisis. Bagian berikut menyediakan berbagai opsi untuk menyesuaikan pekerjaan pemrosesan SageMaker Clarify untuk kasus penggunaan Anda dan jenis analisis yang diinginkan.
### Parameter untuk file konfigurasi analisis
Dalam file konfigurasi analisis, Anda dapat menentukan parameter berikut.
+ **versi** - (Opsional) String versi dari skema file konfigurasi analisis. Jika versi tidak disediakan, SageMaker Clarify menggunakan versi terbaru yang didukung. Saat ini, satu-satunya versi yang didukung adalah`1.0`.
+ **dataset\$1type** — Format dataset. Format dataset input dapat berupa salah satu dari nilai berikut:
+ Tabular
+ `text/csv`untuk CSV
+ `application/jsonlines`untuk [SageMaker format padat AI JSON Lines](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html#cm-jsonlines)
+ `application/json`untuk JSON
+ `application/x-parquet`untuk Apache Parquet
+ `application/x-image`untuk mengaktifkan penjelasan untuk masalah penglihatan komputer
+ Penjelasan model peramalan deret waktu
+ `application/json`untuk JSON
+ **dataset\$1uri** — (Opsional) Pengidentifikasi sumber daya seragam (URI) dari kumpulan data utama. Jika Anda memberikan awalan URI S3, pekerjaan pemrosesan SageMaker Clarify secara rekursif mengumpulkan semua file S3 yang terletak di bawah awalan. Anda dapat memberikan awalan URI S3 atau URI S3 ke file manifes gambar untuk masalah penglihatan komputer. Jika `dataset_uri` disediakan, itu lebih diutamakan daripada input pekerjaan pemrosesan dataset. Untuk semua jenis format kecuali kasus penggunaan gambar dan deret waktu, pekerjaan pemrosesan SageMaker Clarify memuat kumpulan data input ke dalam bingkai data tabel, sebagai kumpulan data **tabular**. Format ini memungkinkan SageMaker AI untuk dengan mudah memanipulasi dan menganalisis dataset input.
+ **header** - (Opsional)
+ **Tabular:** Sebuah array string yang berisi nama kolom dari dataset tabular. Jika nilai tidak disediakan`headers`, tugas pemrosesan SageMaker Clarify akan membaca header dari kumpulan data. Jika kumpulan data tidak memiliki header, maka pekerjaan pemrosesan Clarify secara otomatis menghasilkan nama placeholder berdasarkan indeks kolom berbasis nol. Misalnya, nama placeholder untuk kolom pertama dan kedua adalah**column\$10**,**column\$11**, dan seterusnya.
**catatan**
Dengan konvensi, jika `dataset_type` ada `application/jsonlines` atau`application/json`, maka `headers` harus berisi nama-nama berikut secara berurutan:
nama fitur
nama label (jika `label` ditentukan)
nama label yang diprediksi (jika `predicted_label` ditentukan)
Contoh `headers` untuk tipe `application/jsonlines` dataset jika ditentukan `label` adalah:`["feature1","feature2","feature3","target_label"]`.
+ **Deret waktu:** Daftar nama kolom dalam kumpulan data. Jika tidak disediakan, Clarify menghasilkan header untuk digunakan secara internal. Untuk kasus penjelasan deret waktu, berikan header dengan urutan sebagai berikut:
1. id barang
1. timestamp
1. seri waktu target
1. semua kolom deret waktu terkait
1. semua kolom kovariat statis
+ **label** — (Opsional) Sebuah string atau indeks integer berbasis nol. Jika disediakan, `label` digunakan untuk menemukan label kebenaran dasar, juga dikenal sebagai label yang diamati atau atribut target dalam kumpulan data tabel. Label kebenaran dasar digunakan untuk menghitung metrik bias. Nilai untuk `label` ditentukan tergantung pada nilai `dataset_type` parameter sebagai berikut.
+ Jika `dataset_type` ya**text/csv**, `label` dapat ditentukan sebagai salah satu dari berikut ini:
+ Nama kolom yang valid
+ Indeks yang berada dalam rentang kolom dataset
+ Jika `dataset_type` ya**application/parquet**, `label` harus nama kolom yang valid.
+ Jika `dataset_type` ya**application/jsonlines**, `label` harus berupa [JMESPath](https://jmespath.org/)ekspresi yang ditulis untuk mengekstrak label kebenaran dasar dari kumpulan data. Dengan konvensi, jika `headers` ditentukan, maka harus berisi nama label.
+ Jika `dataset_type` ya**application/json**, `label` harus berupa [JMESPath](https://jmespath.org/)ekspresi yang ditulis untuk mengekstrak label kebenaran dasar untuk setiap catatan dalam kumpulan data. JMESPath Ekspresi ini harus menghasilkan daftar label di mana label ke-i berkorelasi dengan catatan ke-i.
+ **predicted\$1label** — (Opsional) Sebuah string atau indeks integer berbasis nol. Jika disediakan, `predicted_label` digunakan untuk menemukan kolom yang berisi label yang diprediksi dalam kumpulan data tabel. Label yang diprediksi digunakan untuk menghitung metrik **bias** pasca-pelatihan. Parameter `predicted_label` ini opsional jika kumpulan data tidak menyertakan label yang diprediksi. Jika label yang diprediksi diperlukan untuk komputasi, maka pekerjaan pemrosesan SageMaker Clarify akan mendapatkan prediksi dari model.
Nilai untuk `predicted_label` ditentukan tergantung pada nilai `dataset_type` sebagai berikut:
+ Jika `dataset_type` ya**text/csv**, `predicted_label` dapat ditentukan sebagai salah satu dari berikut ini:
+ Nama kolom yang valid. Jika `predicted_label_dataset_uri` ditentukan, tetapi tidak `predicted_label` disediakan, nama label prediksi default adalah “predicted\$1label”.
+ Indeks yang berada dalam rentang kolom dataset. Jika `predicted_label_dataset_uri` ditentukan, maka indeks digunakan untuk menemukan kolom label yang diprediksi dalam kumpulan data label yang diprediksi.
+ Jika dataset\$1type adalah**application/x-parquet**, `predicted_label` harus nama kolom yang valid.
+ Jika dataset\$1type adalah**application/jsonlines**, `predicted_label` harus berupa [JMESPath](https://jmespath.org/)ekspresi valid yang ditulis untuk mengekstrak label yang diprediksi dari kumpulan data. Dengan konvensi, jika `headers` ditentukan, maka harus berisi nama label yang diprediksi.
+ Jika `dataset_type` ya**application/json**, `predicted_label` harus berupa [JMESPath](https://jmespath.org/)ekspresi yang ditulis untuk mengekstrak label yang diprediksi untuk setiap catatan dalam kumpulan data. JMESPath Ekspresi harus menghasilkan daftar label yang diprediksi di mana label prediksi saya adalah untuk catatan ke-i.
+ **fitur** - (Opsional) Diperlukan untuk kasus non-time-series penggunaan jika `dataset_type` ada `application/jsonlines` atau`application/json`. Ekspresi JMESPath string ditulis untuk menemukan fitur dalam dataset input. Untuk`application/jsonlines`, JMESPath ekspresi akan diterapkan ke setiap baris untuk mengekstrak fitur untuk catatan itu. Untuk`application/json`, JMESPath ekspresi akan diterapkan ke seluruh dataset input. JMESPath Ekspresi harus mengekstrak daftar daftar, atau fitur 2D array/matrix di mana baris ke-i berisi fitur yang berkorelasi dengan catatan ke-i. Untuk `dataset_type` dari `text/csv` atau`application/x-parquet`, semua kolom kecuali label kebenaran dasar dan kolom label yang diprediksi secara otomatis ditetapkan sebagai fitur.
+ **predicted\$1label\$1dataset\$1uri — (Opsional) Hanya berlaku jika dataset\$1type** adalah. `text/csv` **URI S3 untuk kumpulan data yang berisi label prediksi yang digunakan untuk menghitung metrik bias pasca-pelatihan.** Pekerjaan pemrosesan SageMaker Clarify akan memuat prediksi dari URI yang disediakan alih-alih mendapatkan prediksi dari model. Dalam hal ini, `predicted_label` diperlukan untuk menemukan kolom label yang diprediksi dalam kumpulan data label yang diprediksi. Jika kumpulan data label yang diprediksi atau kumpulan data utama dibagi menjadi beberapa file, kolom pengidentifikasi harus ditentukan oleh `joinsource_name_or_index` untuk bergabung dengan dua kumpulan data.
+ **predicted\$1label\$1headers** — (Opsional) Hanya berlaku bila ditentukan. `predicted_label_dataset_uri` Array string yang berisi nama kolom dari dataset label yang diprediksi. Selain header label yang diprediksi, juga `predicted_label_headers` dapat berisi header kolom pengidentifikasi untuk bergabung dengan kumpulan data label yang diprediksi dan kumpulan data utama. Untuk informasi selengkapnya, lihat deskripsi berikut untuk parameter`joinsource_name_or_index`.
+ **joinsource\$1name\$1or\$1index** — (Opsional) Nama atau indeks berbasis nol kolom dalam kumpulan data tabular yang akan digunakan sebagai kolom pengenal saat melakukan penggabungan bagian dalam. Kolom ini hanya digunakan sebagai pengenal. Ini tidak digunakan untuk perhitungan lain seperti analisis bias atau analisis atribusi fitur. Nilai untuk `joinsource_name_or_index` diperlukan dalam kasus-kasus berikut:
+ Ada beberapa kumpulan data input, dan siapa pun dibagi menjadi beberapa file.
+ Pemrosesan terdistribusi diaktifkan dengan mengatur pekerjaan pemrosesan SageMaker Clarify [InstanceCount](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProcessingClusterConfig.html#sagemaker-Type-ProcessingClusterConfig-InstanceCount)ke nilai yang lebih besar dari`1`.
+ **excluded\$1columns** — (Opsional) Sebuah array nama atau indeks kolom berbasis nol yang akan dikecualikan dari dikirim ke model sebagai masukan untuk prediksi. Label kebenaran dasar dan label yang diprediksi secara otomatis sudah dikecualikan. Fitur ini tidak didukung untuk deret waktu.
+ **probability\$1threshold** — (Opsional) Nomor floating point di atasnya, label atau objek dipilih. Nilai default-nya adalah `0.5`. Pekerjaan pemrosesan SageMaker Clarify digunakan `probability_threshold` dalam kasus-kasus berikut:
+ Dalam analisis bias pasca-pelatihan, `probability_threshold` ubah prediksi model numerik (nilai probabilitas atau skor) menjadi label biner, jika modelnya adalah pengklasifikasi biner. Skor yang lebih besar dari ambang dikonversi menjadi`1`. Sedangkan, skor kurang dari atau sama dengan ambang dikonversi menjadi`0`.
+ Dalam masalah penjelasan visi komputer, jika model\$1type **OBJECT\$1DETECTION** `, probability_threshold` menyaring objek yang terdeteksi dengan skor kepercayaan lebih rendah dari nilai ambang batas.
+ **label\$1values\$1or\$1threshold** — (Opsional) Diperlukan untuk analisis bias. Array nilai label atau nomor ambang batas, yang menunjukkan hasil positif untuk kebenaran dasar dan label prediksi untuk metrik bias. Untuk informasi lebih lanjut, lihat nilai label positif di[Amazon SageMaker Klarifikasi Persyaratan untuk Bias dan Keadilan](clarify-detect-data-bias.md#clarify-bias-and-fairness-terms). Jika labelnya numerik, ambang batas diterapkan sebagai batas bawah untuk memilih hasil positif. `label_values_or_threshold`Untuk mengatur berbagai jenis masalah, lihat contoh berikut:
+ Untuk masalah klasifikasi biner, label memiliki dua nilai yang mungkin, `0` dan`1`. Jika nilai `1` label menguntungkan untuk kelompok demografis yang diamati dalam sampel, maka `label_values_or_threshold` harus diatur ke`[1]`.
+ Untuk masalah klasifikasi multiclass, label memiliki tiga nilai yang mungkin,**bird**, **cat** dan. **dog** Jika dua yang terakhir mendefinisikan kelompok demografis yang disukai bias, maka `label_values_or_threshold` harus diatur ke. `["cat","dog"]`
+ Untuk masalah regresi, nilai label kontinu, mulai dari `0` hingga. `1` Jika nilai yang lebih besar dari `0.5` seharusnya menunjuk sampel sebagai memiliki hasil positif, maka `label_values_or_threshold` harus diatur ke`0.5`.
+ **facet** — (Opsional) Diperlukan untuk analisis bias. Array objek faset, yang terdiri dari atribut sensitif yang mengukur bias. Anda dapat menggunakan aspek untuk memahami karakteristik bias dari kumpulan data dan model Anda bahkan jika model Anda dilatih tanpa menggunakan atribut sensitif. Untuk informasi lebih lanjut, lihat **Facet** di[Amazon SageMaker Klarifikasi Persyaratan untuk Bias dan Keadilan](clarify-detect-data-bias.md#clarify-bias-and-fairness-terms). Setiap objek facet mencakup bidang-bidang berikut:
+ **name\$1or\$1index** — (Opsional) Nama atau indeks berbasis nol dari kolom atribut sensitif dalam kumpulan data tabular. Jika `facet_dataset_uri` ditentukan, maka indeks mengacu pada dataset faset alih-alih dataset utama.
+ **value\$1or\$1threshold** — (Opsional) Diperlukan jika `facet` numerik dan `label_values_or_threshold` diterapkan sebagai batas bawah untuk memilih grup sensitif). Array nilai faset atau angka ambang batas, yang menunjukkan kelompok demografis sensitif yang disukai bias. Jika tipe data facet kategoris dan tidak `value_or_threshold` disediakan, metrik bias dihitung sebagai satu grup untuk setiap nilai unik (bukan semua nilai). `value_or_threshold`Untuk mengatur tipe `facet` data yang berbeda, lihat contoh berikut:
+ Untuk tipe data facet biner, fitur ini memiliki dua nilai yang mungkin, `0` dan`1`. Jika Anda ingin menghitung metrik bias untuk setiap nilai, maka `value_or_threshold` dapat dihilangkan atau disetel ke array kosong.
+ Untuk tipe data facet kategoris, fitur ini memiliki tiga nilai yang mungkin**bird**,, **cat** dan. **dog** Jika dua yang pertama mendefinisikan kelompok demografis yang disukai bias, maka `value_or_threshold` harus diatur ke. `["bird", "cat"]` Dalam contoh ini, sampel dataset dibagi menjadi dua kelompok demografis. Aspek dalam kelompok yang diuntungkan memiliki nilai **bird** atau**cat**, sedangkan segi dalam kelompok yang kurang beruntung memiliki nilai. **dog**
+ Untuk tipe data facet numerik, nilai fitur kontinu, mulai dari `0` hingga. `1` Sebagai contoh, jika nilai yang lebih besar dari `0.5` seharusnya menunjuk sampel sebagai disukai, maka `value_or_threshold` harus diatur ke. `0.5` Dalam contoh ini, sampel dataset dibagi menjadi dua kelompok demografis. Aspek dalam kelompok yang diuntungkan memiliki nilai lebih besar dari`0.5`, sedangkan segi dalam kelompok yang kurang beruntung memiliki nilai kurang dari atau sama dengan. `0.5`
+ **group\$1variable** — (Opsional) Nama atau indeks berbasis nol dari kolom yang menunjukkan subkelompok yang akan digunakan untuk metrik bias atau. [Disparitas Demografis Bersyarat (CDD)](clarify-data-bias-metric-cddl.md) [Disparitas Demografis Bersyarat dalam Label yang Diprediksi (CDDPL)](clarify-post-training-bias-metric-cddpl.md)
+ **facet\$1dataset\$1uri — (Opsional) Hanya berlaku jika dataset\$1type** adalah. `text/csv` URI S3 untuk kumpulan data yang berisi atribut sensitif untuk analisis bias. Anda dapat menggunakan aspek untuk memahami karakteristik bias dari kumpulan data dan model Anda bahkan jika model Anda dilatih tanpa menggunakan atribut sensitif.
**catatan**
Jika kumpulan data faset atau kumpulan data utama dibagi menjadi beberapa file, kolom pengidentifikasi harus ditentukan oleh `joinsource_name_or_index` untuk bergabung dengan dua kumpulan data. Anda harus menggunakan parameter `facet` untuk mengidentifikasi setiap aspek dalam dataset faset.
+ **facet\$1headers** - (Opsional) Hanya berlaku bila ditentukan. `facet_dataset_uri` Array string yang berisi nama kolom untuk dataset faset, dan secara opsional, header kolom pengidentifikasi untuk bergabung dengan dataset faset dan dataset utama, lihat. `joinsource_name_or_index`
+ **time\$1series\$1data\$1config** - (Opsional) Menentukan konfigurasi yang akan digunakan untuk pengolahan data dari deret waktu.
+ **item\$1id** — Sebuah string atau indeks integer berbasis nol. Bidang ini digunakan untuk menemukan id item di dataset input bersama.
+ **timestamp** — Sebuah string atau indeks integer berbasis nol. Bidang ini digunakan untuk menemukan stempel waktu dalam kumpulan data input bersama.
+ **dataset\$1format** — Nilai yang mungkin adalah`columns`,, atau. `item_records` `timestamp_records` Bidang ini digunakan untuk menggambarkan format kumpulan data JSON, yang merupakan satu-satunya format yang didukung untuk penjelasan deret waktu.
+ **target\$1time\$1series** — Sebuah JMESPath string atau indeks integer berbasis nol. Bidang ini digunakan untuk menemukan deret waktu target dalam kumpulan data input bersama. Jika parameter ini adalah string, maka semua parameter lain kecuali `dataset_format` harus string atau daftar string. Jika parameter ini adalah bilangan bulat, maka semua parameter lain kecuali `dataset_format` harus bilangan bulat atau daftar bilangan bulat.
+ **related\$1time\$1series** — (Opsional) Sebuah array ekspresi. JMESPath Bidang ini digunakan untuk menemukan semua deret waktu terkait dalam kumpulan data input bersama, jika ada.
+ **static\$1covariates** — (Opsional) Sebuah array ekspresi. JMESPath Bidang ini digunakan untuk menemukan semua bidang kovariat statis dalam kumpulan data input bersama, jika ada.
Sebagai contoh, lihat [Contoh konfigurasi kumpulan data deret waktu](clarify-processing-job-data-format-time-series.md#clarify-processing-job-data-format-time-series-ex).
+ **Metode** — Objek yang berisi satu atau lebih metode analisis dan parameternya. Jika ada metode yang dihilangkan, itu tidak digunakan untuk analisis atau dilaporkan.
+ **pre\$1training\$1bias** — Sertakan metode ini jika Anda ingin menghitung metrik bias pra-pelatihan. Penjelasan rinci tentang metrik dapat ditemukan di[Metrik Bias Pra-pelatihan](clarify-measure-data-bias.md). Objek memiliki parameter berikut:
+ **method** — Array yang berisi salah satu metrik bias pra-pelatihan dari daftar berikut yang ingin Anda hitung. Setel `methods` **all** untuk menghitung semua metrik bias pra-pelatihan. Sebagai contoh, array `["CI", "DPL"]` akan menghitung **Ketidakseimbangan Kelas** dan **Perbedaan dalam Proporsi Label.**
+ `CI`untuk [Ketidakseimbangan Kelas (CI)](clarify-bias-metric-class-imbalance.md)
+ `DPL`untuk [Perbedaan Proporsi Label (DPL)](clarify-data-bias-metric-true-label-imbalance.md)
+ `KL`untuk [Divergensi Kullback-Leibler (KL)](clarify-data-bias-metric-kl-divergence.md)
+ `JS`untuk [Divergensi Jensen-Shannon (JS)](clarify-data-bias-metric-jensen-shannon-divergence.md)
+ `LP`untuk [L p -norma (LP)](clarify-data-bias-metric-lp-norm.md)
+ `TVD`untuk [Jarak Variasi Total (TVD)](clarify-data-bias-metric-total-variation-distance.md)
+ `KS`untuk [Kolmogorov-Smirnov (KS)](clarify-data-bias-metric-kolmogorov-smirnov.md)
+ `CDDL`untuk [Disparitas Demografis Bersyarat (CDD)](clarify-data-bias-metric-cddl.md)
+ **post\$1training\$1bias** — Sertakan metode ini jika Anda ingin menghitung metrik bias pasca-pelatihan. Penjelasan rinci tentang metrik dapat ditemukan di[Data Pasca-pelatihan dan Metrik Bias Model](clarify-measure-post-training-bias.md). `post_training_bias`Objek memiliki parameter berikut.
+ **method** — Array yang berisi salah satu metrik bias pasca-pelatihan dari daftar berikut yang ingin Anda hitung. Setel `methods` **all** untuk menghitung semua metrik bias pasca-pelatihan. Sebagai contoh, array `["DPPL", "DI"]` menghitung **Perbedaan Proporsi Positif dalam Label yang Diprediksi** **dan Dampak** Berbeda. Metode yang tersedia adalah sebagai berikut.
+ `DPPL`untuk [Perbedaan Proporsi Positif pada Label Prediksi (DPPL)](clarify-post-training-bias-metric-dppl.md)
+ `DI`untuk [Dampak Berbeda (DI)](clarify-post-training-bias-metric-di.md)
+ `DCA`untuk [Perbedaan Penerimaan Bersyarat () DCAcc](clarify-post-training-bias-metric-dcacc.md)
+ `DCR`untuk [Perbedaan Penolakan Bersyarat (DCR)](clarify-post-training-bias-metric-dcr.md)
+ `SD`untuk [Perbedaan spesifisitas (SD)](clarify-post-training-bias-metric-sd.md)
+ `RD`untuk [Ingat Perbedaan (RD)](clarify-post-training-bias-metric-rd.md)
+ `DAR`untuk [Perbedaan Tingkat Penerimaan (DAR)](clarify-post-training-bias-metric-dar.md)
+ `DRR`untuk [Perbedaan Tingkat Penolakan (DRR)](clarify-post-training-bias-metric-drr.md)
+ `AD`untuk [Perbedaan Akurasi (AD)](clarify-post-training-bias-metric-ad.md)
+ `TE`untuk [Kesetaraan Perawatan (TE)](clarify-post-training-bias-metric-te.md)
+ `CDDPL`untuk [Disparitas Demografis Bersyarat dalam Label yang Diprediksi (CDDPL)](clarify-post-training-bias-metric-cddpl.md)
+ `FT`untuk [Fliptest Kontrafaktual (FT)](clarify-post-training-bias-metric-ft.md)
+ `GE`untuk [Entropi umum (GE)](clarify-post-training-bias-metric-ge.md)
+ **shap** - Sertakan metode ini jika Anda ingin menghitung nilai SHAP. Pekerjaan pemrosesan SageMaker Clarify mendukung algoritma Kernel SHAP. `shap`Objek memiliki parameter berikut.
+ **baseline** — (Opsional) Kumpulan data dasar SHAP, juga dikenal sebagai dataset latar belakang. Persyaratan tambahan untuk kumpulan data dasar dalam kumpulan data tabular atau masalah penglihatan komputer adalah sebagai berikut. Untuk informasi lebih lanjut tentang Garis Dasar SHAP, lihat [Garis Dasar SHAP untuk Penjelasan](clarify-feature-attribute-shap-baselines.md)
+ Untuk kumpulan data **tabular**, `baseline` dapat berupa data dasar di tempat atau URI S3 dari file dasar. Jika tidak `baseline` disediakan, pekerjaan pemrosesan SageMaker Clarify menghitung baseline dengan mengelompokkan kumpulan data input. Berikut ini diperlukan dari baseline:
+ Formatnya harus sama dengan format kumpulan data yang ditentukan oleh`dataset_type`.
+ Garis dasar hanya dapat berisi fitur yang dapat diterima model sebagai input.
+ Dataset dasar dapat memiliki satu atau lebih instance. Jumlah instance dasar secara langsung memengaruhi ukuran kumpulan data sintetis dan runtime pekerjaan.
+ Jika `text_config` ditentukan, maka nilai dasar kolom teks adalah string yang digunakan untuk menggantikan unit teks yang ditentukan oleh. `granularity` Misalnya, satu placeholder umum adalah “[MASK]”, yang digunakan untuk mewakili kata atau potongan teks yang hilang atau tidak dikenal.
Contoh berikut menunjukkan cara mengatur data dasar di tempat untuk parameter yang berbeda: `dataset_type`
+ Jika `dataset_type` salah satu `text/csv` atau`application/x-parquet`, model menerima empat fitur numerik, dan baseline memiliki dua contoh. Dalam contoh ini, jika satu catatan memiliki semua nilai fitur nol dan catatan lainnya memiliki semua satu nilai fitur, maka baseline harus diatur ke`[[0,0,0,0],[1,1,1,1]]`, tanpa header apa pun.
+ Jika `dataset_type` ya`application/jsonlines`, dan `features` merupakan kunci untuk daftar empat nilai fitur numerik. Selain itu, dalam contoh ini, jika baseline memiliki satu catatan dari semua nilai nol, maka `baseline` seharusnya. `[{"features":[0,0,0,0]}]`
+ Jika `dataset_type` ya`application/json`, `baseline` dataset harus memiliki struktur dan format yang sama dengan dataset input.
+ Untuk masalah **penglihatan komputer**, `baseline` bisa berupa URI S3 dari gambar yang digunakan untuk menutupi fitur (segmen) dari gambar input. Pekerjaan pemrosesan SageMaker Clarify memuat gambar topeng dan mengubah ukurannya ke resolusi yang sama dengan gambar input. Jika baseline tidak disediakan, tugas pemrosesan SageMaker Clarify menghasilkan gambar topeng [white noise](https://en.wikipedia.org/wiki/White_noise) pada resolusi yang sama dengan gambar input.
+ **features\$1to\$1explain** — (Opsional) Sebuah array string atau indeks berbasis nol dari kolom fitur untuk menghitung nilai SHAP untuk. Jika tidak `features_to_explain` disediakan, nilai SHAP dihitung untuk semua kolom fitur. Kolom fitur ini tidak dapat menyertakan kolom label atau kolom label yang diprediksi. `features_to_explain`Parameter ini hanya didukung untuk kumpulan data tabular dengan kolom numerik dan kategoris.
+ **num\$1clusters** — (Opsional) Jumlah cluster yang kumpulan data dibagi menjadi untuk menghitung dataset dasar. Setiap cluster digunakan untuk menghitung satu instance dasar. Jika tidak `baseline` ditentukan, pekerjaan pemrosesan SageMaker Clarify mencoba untuk menghitung kumpulan data dasar dengan membagi kumpulan data tabular menjadi jumlah cluster yang optimal antara dan. `1` `12` Jumlah instance dasar secara langsung mempengaruhi runtime analisis SHAP.
+ **num\$1samples** — (Opsional) Jumlah sampel yang akan digunakan dalam algoritma Kernel SHAP. Jika tidak `num_samples` disediakan, pekerjaan pemrosesan SageMaker Clarify memilih nomor untuk Anda. Jumlah sampel secara langsung mempengaruhi ukuran dataset sintetis dan runtime pekerjaan.
+ **seed** — (Opsional) Bilangan bulat yang digunakan untuk menginisialisasi generator bilangan acak semu di penjelasan SHAP untuk menghasilkan nilai SHAP yang konsisten untuk pekerjaan yang sama. Jika seed tidak ditentukan, maka setiap kali pekerjaan yang sama berjalan, model dapat menampilkan nilai SHAP yang sedikit berbeda.
+ **use\$1logit** — (Opsional) Nilai Boolean yang menunjukkan bahwa Anda ingin fungsi logit diterapkan pada prediksi model. Default ke `false`. Jika `use_logit` ya`true`, maka nilai SHAP dihitung menggunakan koefisien regresi logistik, yang dapat diartikan sebagai rasio log-odds.
+ **save\$1local\$1shap\$1values** — (Opsional) Nilai Boolean yang menunjukkan bahwa Anda ingin nilai SHAP lokal dari setiap record dalam dataset disertakan dalam hasil analisis. Default ke `false`.
Jika kumpulan data utama dibagi menjadi beberapa file atau pemrosesan terdistribusi diaktifkan, tentukan juga kolom pengidentifikasi menggunakan parameter. `joinsource_name_or_index` Kolom pengidentifikasi dan nilai SHAP lokal disimpan dalam hasil analisis. Dengan cara ini, Anda dapat memetakan setiap catatan ke nilai SHAP lokalnya.
+ **agg\$1method** — (Opsional) Metode yang digunakan untuk menggabungkan nilai SHAP lokal (nilai SHAP untuk setiap instance) dari semua instance ke nilai SHAP global (nilai SHAP untuk seluruh kumpulan data). Default ke `mean_abs`. Metode berikut dapat digunakan untuk menggabungkan nilai SHAP.
+ **mean\$1abs** — Rata-rata nilai SHAP lokal absolut dari semua instance.
+ **mean\$1sq** — Rata-rata nilai SHAP lokal kuadrat dari semua instance.
+ **median** — Median nilai SHAP lokal dari semua instance.
+ **text\$1config** - Diperlukan untuk penjelasan pemrosesan bahasa alami. Sertakan konfigurasi ini jika Anda ingin memperlakukan kolom teks sebagai teks dan penjelasan harus disediakan untuk masing-masing unit teks. Untuk contoh konfigurasi analisis untuk penjelasan pemrosesan bahasa alami, lihat [Konfigurasi analisis untuk penjelasan pemrosesan bahasa alami](#clarify-analysis-configure-nlp-example)
+ **granularitas** — Satuan granularitas untuk analisis kolom teks. Nilai yang valid adalah `token`, `sentence`, atau `paragraph`. **Setiap unit teks dianggap sebagai fitur**, dan nilai SHAP lokal dihitung untuk setiap unit.
+ **bahasa** — Bahasa kolom teks. Nilai yang valid adalah **chinese****danish**,**dutch**, **english****french**,**german**,**greek**,**italian**,**japanese**,**lithuanian**,**multi-language**,**norwegian bokmål**,**polish**,**portuguese**,**romanian**,**russian**,**spanish**, **afrikaans****albanian**,**arabic**,**armenian**,**basque**,**bengali**,**bulgarian**,**catalan**,**croatian**,**czech**,**estonian**,**finnish**,**gujarati**,**hebrew**, **hindi****hungarian**,**icelandic**,**indonesian**,**irish**,**kannada**,**kyrgyz**,**latvian**,**ligurian**, **luxembourgish****macedonian**,**malayalam**, **marathi****nepali**,**persian**, **sanskrit****serbian**,**setswana**, **sinhala****slovak**, **slovenian****swedish**,**tagalog**, **tamil****tatar**,**telugu**, **thai****turkish**,**ukrainian**, **urdu****vietnamese**,, **yoruba** Masukkan `multi-language` untuk campuran beberapa bahasa.
+ **max\$1top\$1tokens** — (Opsional) Jumlah maksimum token teratas, berdasarkan nilai SHAP global. Default ke `50`. Token dapat muncul beberapa kali dalam kumpulan data. Pekerjaan pemrosesan SageMaker Clarify mengumpulkan nilai SHAP dari setiap token, dan kemudian memilih token teratas berdasarkan nilai SHAP globalnya. Nilai SHAP global dari token teratas yang dipilih disertakan dalam `global_top_shap_text` bagian file analysis.json.
+ Nilai agregasi SHAP lokal.
+ **image\$1config** - Diperlukan untuk penjelasan visi komputer. Sertakan konfigurasi ini jika Anda memiliki kumpulan data input yang terdiri dari gambar dan Anda ingin menganalisisnya untuk dijelaskan dalam masalah penglihatan komputer.
+ **model\$1type** — Jenis model. Nilai yang valid meliputi:
+ `IMAGE_CLASSIFICATION`untuk model klasifikasi gambar.
+ `OBJECT_DETECTION`untuk model deteksi objek.
+ **max\$1objects** — Berlaku hanya jika model\$1type adalah**OBJECT\$1DETECTION**. Jumlah maksimum objek, diurutkan berdasarkan skor kepercayaan, terdeteksi oleh model visi komputer. Setiap objek yang diberi peringkat lebih rendah dari max\$1objects teratas berdasarkan skor kepercayaan disaring. Default ke `3`.
+ **context** - Berlaku hanya jika model\$1type adalah. **OBJECT\$1DETECTION** Ini menunjukkan apakah area di sekitar kotak pembatas objek yang terdeteksi ditutupi oleh gambar dasar atau tidak. Nilai yang valid adalah `0` untuk menutupi semuanya, atau `1` untuk menutupi apa pun. Default ke 1.
+ **iou\$1threshold** — Berlaku hanya jika `model_type` metrik persimpangan minimum over union (IOU) untuk mengevaluasi prediksi terhadap deteksi asli. **OBJECT\$1DETECTION** Metrik IOU yang tinggi sesuai dengan tumpang tindih besar antara kotak deteksi kebenaran yang diprediksi dan ground. Default ke `0.5`.
+ **num\$1segment** — (Opsional) Sebuah integer yang menentukan perkiraan jumlah segmen yang akan diberi label dalam gambar input. Setiap segmen gambar dianggap sebagai fitur, dan nilai SHAP lokal dihitung untuk setiap segmen. Default ke `20`.
+ **segment\$1compactness** [— (Opsional) Bilangan bulat yang menentukan bentuk dan ukuran segmen gambar yang dihasilkan oleh metode scikit-image slic.](https://scikit-image.org/docs/dev/api/skimage.segmentation.html#skimage.segmentation.slic) Default ke `5`.
+ **pdp** — Sertakan metode ini untuk menghitung plot ketergantungan paral ()PDPs. Untuk contoh konfigurasi analisis yang akan dihasilkan PDPs, lihat [Hitung plot ketergantungan paral () PDPs](#clarify-analysis-configure-csv-example-pdp)
+ **fitur** - Wajib jika `shap` metode tidak diminta. Array nama fitur atau indeks untuk menghitung dan memplot plot PDP.
+ **top\$1k\$1features** - (Opsional) Menentukan jumlah fitur teratas yang digunakan untuk menghasilkan plot PDP. Jika tidak `features` disediakan, tetapi `shap` metode diminta, maka pekerjaan pemrosesan SageMaker Clarify memilih fitur teratas berdasarkan atribusi SHAP mereka. Default ke `10`.
+ **grid\$1resolution** — Jumlah bucket untuk membagi rentang nilai numerik menjadi. Ini menentukan granularitas grid untuk plot PDP.
+ **asymmetric\$1shapley\$1value** — Sertakan metode ini jika Anda ingin menghitung metrik penjelasan untuk model peramalan deret waktu. Pekerjaan pemrosesan SageMaker Clarify mendukung algoritma nilai Shapley asimetris. Nilai Shapley asimetris adalah varian dari nilai Shapley yang menjatuhkan aksioma simetri. Untuk informasi lebih lanjut, lihat [Nilai Shapley asimetris: menggabungkan pengetahuan kausal](https://arxiv.org/abs/1910.06358) ke dalam penjelasan model-agnostik. Gunakan nilai-nilai ini untuk menentukan bagaimana fitur berkontribusi pada hasil peramalan. Nilai Shapley asimetris memperhitungkan dependensi temporal dari data deret waktu yang diambil oleh model peramalan sebagai input.
Algoritma mencakup parameter berikut:
+ **arah** — Jenis yang tersedia adalah`chronological`,`anti_chronological`, dan`bidirectional`. Struktur temporal dapat dinavigasi dalam urutan kronologis atau anti-kronologis atau keduanya. Penjelasan kronologis dibangun dengan menambahkan informasi secara berulang sejak langkah pertama dan seterusnya. Penjelasan anti-kronologis menambahkan informasi mulai dari langkah terakhir dan bergerak mundur. Urutan terakhir mungkin lebih tepat dengan adanya bias kebaruan, seperti untuk memperkirakan harga saham.
+ **granularitas** — Penjelasan granularitas yang akan digunakan. Opsi granularitas yang tersedia ditampilkan sebagai berikut:
+ **timewise** — `timewise` penjelasan tidak mahal dan memberikan informasi tentang langkah-langkah waktu tertentu saja, seperti mencari tahu seberapa banyak informasi dari hari ke-n di masa lalu berkontribusi pada peramalan hari ke-m di masa depan. Atribusi yang dihasilkan tidak menjelaskan kovariat statis secara individual dan tidak membedakan antara target dan deret waktu terkait.
+ **fine\$1grained** — `fine_grained` penjelasan secara komputasi lebih intensif tetapi memberikan rincian lengkap dari semua atribusi variabel input. Metode ini menghitung perkiraan penjelasan untuk mengurangi runtime. Untuk informasi selengkapnya, lihat parameter berikut`num_samples`.
**catatan**
`fine_grained`penjelasan hanya mendukung `chronological` pesanan.
+ **num\$1samples** — (Opsional) Argumen ini diperlukan untuk `fine_grained` penjelasan. Semakin tinggi angkanya, semakin tepat perkiraan. Angka ini harus diskalakan dengan dimensi fitur input. Aturan praktisnya adalah mengatur variabel ini ke *(1 \$1 maks (jumlah deret waktu terkait, jumlah kovariat statis)) ^2* jika hasilnya tidak terlalu besar.
+ **baseline** — (Opsional) Konfigurasi dasar untuk mengganti out-of-coalition nilai untuk kumpulan data yang sesuai (juga dikenal sebagai data latar belakang). Cuplikan berikut menunjukkan contoh konfigurasi dasar:
```
{
"related_time_series": "zero",
"static_covariates": {
: [0, 2],
: [-1, 1]
},
"target_time_series": "zero"
}
```
+ Untuk data temporal seperti deret waktu target atau deret waktu terkait, jenis nilai dasar dapat berupa salah satu dari nilai berikut:
+ `zero`— Semua out-of-coalition nilai diganti dengan 0.0.
+ `mean`— Semua out-of-coalition nilai diganti dengan rata-rata deret waktu.
+ Untuk kovariat statis, entri dasar hanya boleh diberikan ketika permintaan model mengambil nilai kovariat statis, dalam hal ini bidang ini diperlukan. Garis dasar harus disediakan untuk setiap item sebagai daftar. Misalnya, jika Anda memiliki kumpulan data dengan dua kovariat statis, konfigurasi dasar Anda mungkin sebagai berikut:
```
"static_covariates": {
: [1, 1],
: [0, 1]
}
```
Dalam contoh sebelumnya, ** dan ** merupakan id item dari kumpulan data.
+ **report** — (Opsional) Gunakan objek ini untuk menyesuaikan laporan analisis. Parameter ini tidak didukung untuk pekerjaan penjelasan deret waktu. Ada tiga salinan laporan yang sama sebagai bagian dari hasil analisis: laporan Jupyter Notebook, laporan HTML, dan laporan PDF. Objek memiliki parameter berikut:
+ **nama** — Nama file dari file laporan. Misalnya, jika `name` ya**MyReport**, maka file laporan adalah`MyReport.ipynb`,`MyReport.html`, dan`MyReport.pdf`. Default ke `report`.
+ **title** - (Opsional) String judul untuk laporan. Default ke **SageMaker AI Analysis Report**.
+ **prediktor** — Diperlukan jika analisis membutuhkan prediksi dari model. Misalnya, ketika`shap`,`asymmetric_shapley_value`, atau `post_training_bias` metode diminta`pdp`, tetapi label yang diprediksi tidak disediakan sebagai bagian dari kumpulan data input. Berikut ini adalah parameter yang akan digunakan bersama dengan`predictor`:
+ **model\$1name** — Nama model SageMaker AI Anda yang dibuat oleh API. [CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html) Jika Anda menentukan `model_name` alih-alih endpoint\$1name, pekerjaan pemrosesan SageMaker Clarify membuat titik akhir singkat dengan nama model, yang dikenal sebagai titik akhir **bayangan, dan mendapatkan prediksi dari titik akhir**. Pekerjaan menghapus titik akhir bayangan setelah perhitungan selesai. Jika modelnya multi-model, maka `target_model` parameternya harus ditentukan. Untuk informasi selengkapnya tentang titik akhir multi-model, lihat. [Titik akhir multi-model](multi-model-endpoints.md)
+ **endpoint\$1name\$1prefix — (Opsional) Sebuah awalan** nama kustom untuk titik akhir bayangan. Berlaku jika Anda memberikan `model_name` alih-alih`endpoint_name`. Misalnya, berikan `endpoint_name_prefix` jika Anda ingin membatasi akses ke titik akhir dengan nama titik akhir. Awalan harus sesuai dengan [EndpointName](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html#sagemaker-CreateEndpoint-request-EndpointName)pola, dan panjang maksimumnya adalah`23`. Default ke `sm-clarify`.
+ **initial\$1instance\$1count** - Menentukan jumlah contoh untuk titik akhir bayangan. Diperlukan jika Anda memberikan model\$1name alih-alih endpoint\$1name. Nilai untuk `initial_instance_count` bisa berbeda dari pekerjaan, tetapi kami merekomendasikan rasio 1:1. [InstanceCount](https://docs.aws.amazon.com//sagemaker/latest/APIReference/API_ProcessingClusterConfig.html#sagemaker-Type-ProcessingClusterConfig-InstanceCount)
+ **instance\$1type** - Menentukan jenis contoh untuk titik akhir bayangan. Diperlukan jika Anda memberikan `model_name` alih-alih`endpoint_name`. Sebagai contoh, `instance_type` dapat diatur ke “ml.m5.large”. Dalam beberapa kasus, nilai yang ditentukan untuk `instance_type` dapat membantu mengurangi waktu inferensi model. Misalnya, untuk berjalan secara efisien, model pemrosesan bahasa alami dan model visi komputer biasanya memerlukan jenis instance unit pemrosesan grafis (GPU).
+ **endpoint\$1name — Nama** titik akhir SageMaker AI Anda yang dibuat oleh API. [CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) Jika disediakan, lebih `endpoint_name` diutamakan daripada parameter. `model_name` Menggunakan titik akhir yang ada mengurangi waktu bootstrap titik akhir bayangan, tetapi juga dapat menyebabkan peningkatan beban yang signifikan untuk titik akhir tersebut. Selain itu, beberapa metode analisis (seperti `shap` dan`pdp`) menghasilkan dataset sintetis yang dikirim ke titik akhir. Hal ini dapat menyebabkan metrik titik akhir atau data yang diambil terkontaminasi oleh data sintetis, yang mungkin tidak secara akurat mencerminkan penggunaan dunia nyata. Untuk alasan ini, umumnya tidak disarankan untuk menggunakan titik akhir produksi yang ada untuk analisis SageMaker Clarify.
+ **target\$1model** — Nilai string yang diteruskan ke TargetModel parameter SageMaker AI [InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html#RequestSyntax)API. Diperlukan jika model Anda (ditentukan oleh parameter model\$1name) atau titik akhir (ditentukan oleh parameter endpoint\$1name) adalah multi-model. Untuk informasi selengkapnya tentang titik akhir multi-model, lihat. [Titik akhir multi-model](multi-model-endpoints.md)
+ **custom\$1attributes** — (Opsional) String yang memungkinkan Anda memberikan informasi tambahan tentang permintaan inferensi yang dikirimkan ke titik akhir. Nilai string diteruskan ke `CustomAttributes` parameter SageMaker AI [InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html#RequestSyntax)API.
+ **content\$1type** — content\$1type — Format input model yang akan digunakan untuk mendapatkan prediksi dari titik akhir. Jika disediakan, itu diteruskan ke `ContentType` parameter SageMaker AI [InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html#RequestSyntax)API.
+ Untuk penjelasan visi komputer, nilai yang valid adalah**image/jpeg**, **image/png** atau. **application/x-npy** Jika tidak `content_type` disediakan, nilai defaultnya adalah**image/jpeg**.
+ Untuk penjelasan peramalan deret waktu, nilai yang valid adalah. **application/json**
+ Untuk jenis penjelasan lainnya, nilai yang valid adalah**text/csv**, **application/jsonlines,** dan. **application/json** Nilai untuk `content_type` diperlukan jika `dataset_type` ada**application/x-parquet**. Jika tidak `content_type` default ke nilai parameter. `dataset_type`
+ **accept\$1type** — Format keluaran model yang akan digunakan untuk mendapatkan prediksi dari titik akhir. Nilai untuk `accept_type` diteruskan ke `Accept` parameter SageMaker AI [InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html#RequestSyntax)API.
+ Untuk penjelasan visi komputer, jika `model_type` adalah “OBJECT\$1DETECTION” maka defaultnya. `accept_type` **application/json**
+ Untuk penjelasan peramalan deret waktu, nilai yang valid adalah. **application/json**
+ Untuk jenis penjelasan lainnya, nilai yang valid adalah**text/csv**,**application/jsonlines**, dan. **application/json** Jika nilai untuk tidak `accept_type` disediakan, `accept_type` default ke nilai parameter. `content_type`
+ **content\$1template** — String template yang digunakan untuk membangun input model dari catatan dataset. Parameter hanya `content_template` digunakan dan diperlukan jika nilai `content_type` parameternya salah satu `application/jsonlines` atau`application/json`.
Ketika `content_type` parameternya`application/jsonlines`, template seharusnya hanya memiliki satu placeholder`$features`, yang digantikan oleh daftar fitur saat runtime. Misalnya, jika template adalah`"{\"myfeatures\":$features}"`, dan jika catatan memiliki tiga nilai fitur numerik:`1`, `2` dan`3`, maka catatan akan dikirim ke model sebagai JSON Line. `{"myfeatures":[1,2,3]}`
Ketika `content_type` ada`application/json`, template dapat memiliki placeholder `$record` atau. `records` Jika placeholder adalah`record`, satu record diganti dengan record yang memiliki template yang `record_template` diterapkan padanya. Dalam hal ini, hanya satu catatan yang akan dikirim ke model sekaligus. Jika placeholder adalah`$records`, catatan diganti dengan daftar catatan, masing-masing dengan template yang disediakan oleh. `record_template`
+ **record\$1template** — String template yang akan digunakan untuk membangun setiap catatan input model dari instance dataset. Ini hanya digunakan dan diperlukan kapan `content_type` saja`application/json`. String template mungkin berisi salah satu dari berikut ini:
+ `$features`Parameter placeholder yang digantikan oleh array nilai fitur. Placeholder opsional tambahan dapat menggantikan nama header kolom fitur di. `$feature_names` Placeholder opsional ini akan diganti dengan array nama fitur.
+ Tepat satu placeholder `$features_kvp` yang digantikan oleh pasangan kunci-nilai, nama fitur dan nilai fitur.
+ Fitur dalam `headers` konfigurasi. Sebagai contoh, nama `A` fitur, yang dinotasikan oleh sintaks placeholder `"${A}"` akan diganti dengan nilai fitur untuk. `A`
Nilai untuk `record_template` digunakan dengan `content_template` untuk membangun input model. Contoh konfigurasi yang menunjukkan cara membuat input model menggunakan konten dan merekam template berikut.
Dalam contoh kode berikut, header dan fitur didefinisikan sebagai berikut.
+ ``headers`:["A", "B"]`
+ ``features`:[[0,1], [3,4]]`
Contoh masukan model adalah sebagai berikut.
```
{
"instances": [[0, 1], [3, 4]],
"feature_names": ["A", "B"]
}
```
Contoh `content_template` dan nilai `record_template` parameter untuk membangun contoh masukan model sebelumnya berikut.
+ `content_template: "{\"instances\": $records, \"feature_names\": $feature_names}"`
+ `record_template: "$features"`
Dalam contoh kode berikut, header dan fitur didefinisikan sebagai berikut.
```
[
{ "A": 0, "B": 1 },
{ "A": 3, "B": 4 },
]
```
Contoh ` content_template` dan nilai `record_template` parameter untuk membangun contoh masukan model sebelumnya berikut.
+ `content_template: "$records"`
+ `record_template: "$features_kvp"`
Contoh kode alternatif untuk membangun contoh masukan model sebelumnya berikut.
+ `content_template: "$records"`
+ `record_template: "{\"A\": \"${A}\", \"B\": \"${B}\"}"`
Dalam contoh kode berikut, header dan fitur didefinisikan sebagai berikut.
```
{ "A": 0, "B": 1 }
```
Contoh parameter content\$1template dan record\$1template nilai untuk membangun di atas: contoh masukan model sebelumnya berikut.
+ `content_template: "$record"`
+ `record_template: "$features_kvp"`
Untuk contoh lainnya, lihat [Permintaan titik akhir untuk data deret waktu](clarify-processing-job-data-format-time-series-request-jsonlines.md).
+ **label** — (Opsional) Indeks bilangan bulat berbasis nol atau string JMESPath ekspresi yang digunakan untuk mengekstrak label yang diprediksi dari keluaran model untuk analisis bias. Jika modelnya multiclass dan `label` parameter mengekstrak semua label yang diprediksi dari output model, maka berikut ini berlaku. Fitur ini tidak didukung untuk deret waktu.
+ `probability`Parameter diperlukan untuk mendapatkan probabilitas (atau skor) yang sesuai dari output model.
+ Label prediksi skor tertinggi dipilih.
Nilai untuk `label` tergantung pada nilai parameter accept\$1type sebagai berikut.
+ Jika `accept_type` ya**text/csv**, maka `label` adalah indeks dari setiap label yang diprediksi dalam output model.
+ Jika `accept_type` adalah **application/jsonlines** atau**application/json**, maka `label` adalah JMESPath ekspresi yang diterapkan pada output model untuk mendapatkan label yang diprediksi.
+ **label\$1headers** — (Opsional) Sebuah array nilai yang label dapat mengambil dalam dataset. Jika analisis bias diminta, maka `probability` parameter juga diperlukan untuk mendapatkan nilai probabilitas (skor) yang sesuai dari output model, dan label prediksi dari skor tertinggi dipilih. Jika analisis penjelasan diminta, header label digunakan untuk mempercantik laporan analisis. Nilai untuk `label_headers` diperlukan untuk penjelasan visi komputer. Misalnya, untuk masalah klasifikasi multiclass, jika label memiliki tiga nilai yang mungkin,,, dan **bird** **cat****dog**, maka `label_headers` harus disetel ke. `["bird","cat","dog"]`
+ **probabilitas** — (Opsional) Indeks bilangan bulat berbasis nol atau string JMESPath ekspresi yang digunakan untuk mengekstrak probabilitas (skor) untuk analisis penjelasan (tetapi tidak untuk penjelasan deret waktu), atau untuk memilih label yang diprediksi untuk analisis bias. Nilai `probability` tergantung pada nilai `accept_type` parameter sebagai berikut.
+ Jika ya**text/csv**, `accept_type` `probability` adalah indeks probabilitas (skor) dalam output model. Jika tidak `probability` disediakan, seluruh output model diambil sebagai probabilitas (skor).
+ Jika `accept_type` adalah data JSON (salah satu **application/jsonlines** atau**application/json**), `probability` harus berupa JMESPath ekspresi yang digunakan untuk mengekstrak probabilitas (skor) dari output model.
+ **time\$1series\$1predictor\$1config** - (Opsional) Digunakan hanya untuk penjelasan deret waktu. Digunakan untuk menginstruksikan prosesor SageMaker Clarify cara mengurai data dengan benar dari data yang diteruskan sebagai URI S3 di. `dataset_uri`
+ **forecast** — JMESPath Ekspresi yang digunakan untuk mengekstrak hasil perkiraan.
## Contoh file konfigurasi analisis
Bagian berikut berisi contoh file konfigurasi analisis untuk data dalam format CSV, format JSON Lines, dan untuk pemrosesan bahasa alami (NLP), visi komputer (CV), dan penjelasan deret waktu (TS).
### Konfigurasi analisis untuk kumpulan data CSV
Contoh berikut menunjukkan cara mengkonfigurasi bias dan analisis penjelasan untuk dataset tabel dalam format CSV. Dalam contoh ini, dataset yang masuk memiliki empat kolom fitur, dan satu kolom label biner,. `Target` Isi dataset adalah sebagai berikut. Nilai label `1` menunjukkan hasil positif. Dataset disediakan untuk pekerjaan SageMaker Clarify dengan input `dataset` pemrosesan.
```
"Target","Age","Gender","Income","Occupation"
0,25,0,2850,2
1,36,0,6585,0
1,22,1,1759,1
0,48,0,3446,1
...
```
Bagian berikut menunjukkan cara menghitung metrik bias pra-pelatihan dan pasca-pelatihan, nilai SHAP, dan plot ketergantungan sebagian (PDPs) yang menunjukkan pentingnya fitur untuk kumpulan data dalam format CSV.
#### Hitung semua metrik bias pra-pelatihan
Contoh konfigurasi ini menunjukkan cara mengukur apakah kumpulan data sampel sebelumnya bias terhadap sampel dengan **Gender** nilai. `0` Konfigurasi analisis berikut menginstruksikan pekerjaan pemrosesan SageMaker Clarify untuk menghitung semua metrik bias pra-pelatihan untuk kumpulan data.
```
{
"dataset_type": "text/csv",
"label": "Target",
"label_values_or_threshold": [1],
"facet": [
{
"name_or_index": "Gender",
"value_or_threshold": [0]
}
],
"methods": {
"pre_training_bias": {
"methods": "all"
}
}
}
```
#### Hitung semua metrik bias pasca-pelatihan
Anda dapat menghitung metrik bias pra-pelatihan sebelum pelatihan. Namun, Anda harus memiliki model terlatih untuk menghitung metrik bias pasca-pelatihan. Contoh output berikut adalah dari model klasifikasi biner yang mengeluarkan data dalam format CSV. Dalam contoh output ini, setiap baris berisi dua kolom. Kolom pertama berisi label yang diprediksi, dan kolom kedua berisi nilai probabilitas untuk label tersebut.
```
0,0.028986845165491
1,0.825382471084594
...
```
Contoh konfigurasi berikut menginstruksikan pekerjaan pemrosesan SageMaker Clarify untuk menghitung semua metrik bias yang mungkin menggunakan kumpulan data dan prediksi dari keluaran model. Dalam contoh, model tersebut digunakan ke titik akhir SageMaker `your_endpoint` AI.
**catatan**
Dalam contoh kode berikut, parameter `content_type` dan tidak `accept_type` diatur. Oleh karena itu, mereka secara otomatis menggunakan nilai parameter dataset\$1type, yaitu. `text/csv`
```
{
"dataset_type": "text/csv",
"label": "Target",
"label_values_or_threshold": [1],
"facet": [
{
"name_or_index": "Gender",
"value_or_threshold": [0]
}
],
"methods": {
"pre_training_bias": {
"methods": "all"
},
"post_training_bias": {
"methods": "all"
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"label": 0
}
}
```
#### Hitung nilai SHAP
Contoh konfigurasi analisis berikut menginstruksikan pekerjaan untuk menghitung nilai SHAP yang menunjuk `Target` kolom sebagai label dan semua kolom lainnya sebagai fitur.
```
{
"dataset_type": "text/csv",
"label": "Target",
"methods": {
"shap": {
"num_clusters": 1
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"probability": 1
}
}
```
Dalam contoh ini, `baseline` parameter SHAP dihilangkan dan nilai parameternya adalah. `num_clusters` `1` Ini menginstruksikan prosesor SageMaker Clarify untuk menghitung satu sampel dasar SHAP. Dalam contoh ini, probabilitas diatur ke`1`. Ini menginstruksikan pekerjaan pemrosesan SageMaker Clarify untuk mengekstrak skor probabilitas dari kolom kedua dari output model (menggunakan pengindeksan berbasis nol).
#### Hitung plot ketergantungan paral () PDPs
Contoh berikut menunjukkan bagaimana melihat pentingnya `Income` fitur pada laporan analisis menggunakan PDPs. Parameter laporan menginstruksikan pekerjaan pemrosesan SageMaker Clarify untuk menghasilkan laporan. Setelah pekerjaan selesai, laporan yang dihasilkan disimpan sebagai report.pdf ke `analysis_result` lokasi. `grid_resolution`Parameter membagi rentang nilai fitur ke dalam `10` ember. Bersama-sama, parameter yang ditentukan dalam contoh berikut menginstruksikan pekerjaan pemrosesan SageMaker Clarify untuk menghasilkan laporan yang berisi grafik PDP `Income` dengan `10` segmen pada sumbu x. Sumbu y akan menunjukkan dampak marjinal `Income` pada prediksi.
```
{
"dataset_type": "text/csv",
"label": "Target",
"methods": {
"pdp": {
"features": ["Income"],
"grid_resolution": 10
},
"report": {
"name": "report"
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"probability": 1
},
}
```
#### Hitung metrik bias dan kepentingan fitur
Anda dapat menggabungkan semua metode dari contoh konfigurasi sebelumnya ke dalam satu file konfigurasi analisis dan menghitung semuanya dengan satu pekerjaan. Contoh berikut menunjukkan konfigurasi analisis dengan semua langkah digabungkan.
Dalam contoh ini, `probability` parameter diatur `1` untuk menunjukkan bahwa probabilitas terkandung dalam kolom kedua (menggunakan pengindeksan berbasis nol). Namun, karena analisis bias membutuhkan label yang diprediksi, `probability_threshold` parameter diatur `0.5` untuk mengubah skor probabilitas menjadi label biner. Dalam contoh ini, `top_k_features` parameter `pdp` metode plot ketergantungan paral diatur ke`2`. Ini SageMaker menginstruksikan pekerjaan pemrosesan Clarify untuk menghitung plot ketergantungan paral (PDPs) untuk `2` fitur teratas dengan nilai SHAP global terbesar.
```
{
"dataset_type": "text/csv",
"label": "Target",
"probability_threshold": 0.5,
"label_values_or_threshold": [1],
"facet": [
{
"name_or_index": "Gender",
"value_or_threshold": [0]
}
],
"methods": {
"pre_training_bias": {
"methods": "all"
},
"post_training_bias": {
"methods": "all"
},
"shap": {
"num_clusters": 1
},
"pdp": {
"top_k_features": 2,
"grid_resolution": 10
},
"report": {
"name": "report"
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"probability": 1
}
}
```
Alih-alih menerapkan model ke titik akhir, Anda dapat memberikan nama model SageMaker AI Anda ke pekerjaan pemrosesan SageMaker Clarify menggunakan parameter. `model_name` Contoh berikut menunjukkan bagaimana menentukan model bernama**your\$1model**. Pekerjaan pemrosesan SageMaker Clarify akan membuat titik akhir bayangan menggunakan konfigurasi.
```
{
...
"predictor": {
"model_name": "your_model",
"initial_instance_count": 1,
"instance_type": "ml.m5.large",
"probability": 1
}
}
```
### Konfigurasi analisis untuk dataset JSON Lines
Contoh berikut menunjukkan cara mengkonfigurasi analisis bias dan analisis penjelasan untuk dataset tabel dalam format JSON Lines. Dalam contoh ini, dataset yang masuk memiliki data yang sama dengan bagian sebelumnya tetapi mereka berada dalam format padat SageMaker AI JSON Lines. Setiap baris adalah objek JSON yang valid. Kunci “Fitur” menunjuk ke array nilai fitur, dan kunci “Label” menunjuk ke label kebenaran dasar. Dataset disediakan untuk pekerjaan SageMaker Clarify dengan input pemrosesan “dataset”. Untuk informasi lebih lanjut tentang JSON Lines, lihat[Format permintaan JSONLINES](cdf-inference.md#cm-jsonlines).
```
{"Features":[25,0,2850,2],"Label":0}
{"Features":[36,0,6585,0],"Label":1}
{"Features":[22,1,1759,1],"Label":1}
{"Features":[48,0,3446,1],"Label":0}
...
```
Bagian berikut menunjukkan cara menghitung metrik bias pra-pelatihan dan pasca-pelatihan, nilai SHAP, dan plot ketergantungan sebagian (PDPs) yang menunjukkan pentingnya fitur untuk kumpulan data dalam format JSON Lines.
#### Hitung metrik bias pra-pelatihan
Tentukan label, fitur, format, dan metode untuk mengukur metrik bias pra-pelatihan untuk `Gender` nilai. `0` Dalam contoh berikut, `headers` parameter memberikan nama fitur terlebih dahulu. Nama label diberikan terakhir. Menurut konvensi, header terakhir adalah header label.
`features`Parameter diatur ke JMESPath ekspresi “Fitur” sehingga pekerjaan pemrosesan SageMaker Clarify dapat mengekstrak array fitur dari setiap catatan. `label`Parameter diatur ke JMESPath ekspresi “Label” sehingga pekerjaan pemrosesan SageMaker Clarify dapat mengekstrak label kebenaran dasar dari setiap rekaman. Gunakan nama facet untuk menentukan atribut sensitif, sebagai berikut.
```
{
"dataset_type": "application/jsonlines",
"headers": ["Age","Gender","Income","Occupation","Target"],
"label": "Label",
"features": "Features",
"label_values_or_threshold": [1],
"facet": [
{
"name_or_index": "Gender",
"value_or_threshold": [0]
}
],
"methods": {
"pre_training_bias": {
"methods": "all"
}
}
}
```
#### Hitung semua metrik bias
Anda harus memiliki model terlatih untuk menghitung metrik bias pasca-pelatihan. Contoh berikut adalah dari model klasifikasi biner yang mengeluarkan data JSON Lines dalam format contoh. Setiap baris output model adalah objek JSON yang valid. `predicted_label`Poin kunci untuk label yang diprediksi, dan `probability` poin-poin kunci untuk nilai probabilitas.
```
{"predicted_label":0,"probability":0.028986845165491}
{"predicted_label":1,"probability":0.825382471084594}
...
```
Anda dapat menerapkan model ke titik akhir SageMaker AI bernama. `your_endpoint` Contoh konfigurasi analisis berikut menginstruksikan pekerjaan pemrosesan SageMaker Clarify untuk menghitung semua metrik bias yang mungkin untuk kumpulan data dan model. Dalam contoh ini, parameter `content_type` dan tidak `accept_type` diatur. Oleh karena itu, mereka secara otomatis diatur untuk menggunakan nilai parameter dataset\$1type, yaitu. `application/jsonlines` Pekerjaan pemrosesan SageMaker Clarify menggunakan `content_template` parameter untuk menyusun input model, dengan mengganti `$features` placeholder dengan array fitur.
```
{
"dataset_type": "application/jsonlines",
"headers": ["Age","Gender","Income","Occupation","Target"],
"label": "Label",
"features": "Features",
"label_values_or_threshold": [1],
"facet": [
{
"name_or_index": "Gender",
"value_or_threshold": [0]
}
],
"methods": {
"pre_training_bias": {
"methods": "all"
},
"post_training_bias": {
"methods": "all"
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"content_template": "{\"Features\":$features}",
"label": "predicted_label"
}
}
```
#### Hitung nilai SHAP
Karena analisis SHAP tidak memerlukan label kebenaran dasar, `label` parameternya dihilangkan. Dalam contoh ini, `headers` parameter juga dihilangkan. Oleh karena itu, pekerjaan pemrosesan SageMaker Clarify harus menghasilkan placeholder menggunakan nama generik seperti `column_0` atau `column_1` untuk header fitur, dan `label0` untuk header label. Anda dapat menentukan nilai untuk `headers` dan `label` untuk a untuk meningkatkan keterbacaan hasil analisis. Karena parameter probabilitas diatur ke JMESPath ekspresi`probability`, nilai probabilitas akan diekstraksi dari output model. Berikut ini adalah contoh untuk menghitung nilai SHAP.
```
{
"dataset_type": "application/jsonlines",
"features": "Features",
"methods": {
"shap": {
"num_clusters": 1
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"content_template": "{\"Features\":$features}",
"probability": "probability"
}
}
```
#### Hitung plot ketergantungan paral () PDPs
Contoh berikut menunjukkan bagaimana melihat pentingnya “Penghasilan” pada PDP. Dalam contoh ini, header fitur tidak disediakan. Oleh karena itu, `features` parameter `pdp` metode harus menggunakan indeks berbasis nol untuk merujuk ke lokasi kolom fitur. `grid_resolution`Parameter membagi rentang nilai fitur ke dalam `10` ember. Bersama-sama, parameter dalam contoh menginstruksikan pekerjaan pemrosesan SageMaker Clarify untuk menghasilkan laporan yang berisi grafik PDP `Income` dengan `10` segmen pada sumbu x. Sumbu y akan menunjukkan dampak marjinal `Income` pada prediksi.
```
{
"dataset_type": "application/jsonlines",
"features": "Features",
"methods": {
"pdp": {
"features": [2],
"grid_resolution": 10
},
"report": {
"name": "report"
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"content_template": "{\"Features\":$features}",
"probability": "probability"
}
}
```
#### Hitung metrik bias dan kepentingan fitur
Anda dapat menggabungkan semua metode sebelumnya ke dalam satu file konfigurasi analisis dan menghitung semuanya dengan satu pekerjaan. Contoh berikut menunjukkan konfigurasi analisis dengan semua langkah digabungkan. Dalam contoh ini, `probability` parameter diatur. Tetapi karena analisis bias membutuhkan label yang diprediksi, `probability_threshold` parameter diatur `0.5` untuk mengubah skor probabilitas menjadi label biner. Dalam contoh ini, `top_k_features` parameter `pdp` metode diatur ke`2`. Ini menginstruksikan tugas pemrosesan SageMaker Clarify PDPs untuk menghitung `2` fitur teratas dengan nilai SHAP global terbesar.
```
{
"dataset_type": "application/jsonlines",
"headers": ["Age","Gender","Income","Occupation","Target"],
"label": "Label",
"features": "Features",
"probability_threshold": 0.5,
"label_values_or_threshold": [1],
"facet": [
{
"name_or_index": "Gender",
"value_or_threshold": [0]
}
],
"methods": {
"pre_training_bias": {
"methods": "all"
},
"post_training_bias": {
"methods": "all"
},
"shap": {
"num_clusters": 1
},
"pdp": {
"top_k_features": 2,
"grid_resolution": 10
},
"report": {
"name": "report"
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"content_template": "{\"Features\":$features}",
"probability": "probability"
}
}
```
### Konfigurasi analisis untuk dataset JSON
Contoh berikut menunjukkan cara mengkonfigurasi bias dan analisis penjelasan untuk dataset tabel dalam format JSON. Dalam contoh ini, dataset yang masuk memiliki data yang sama dengan bagian sebelumnya tetapi mereka berada dalam format padat SageMaker AI JSON. Untuk informasi lebih lanjut tentang JSON Lines, lihat[Format permintaan JSONLINES](cdf-inference.md#cm-jsonlines).
Seluruh permintaan input adalah JSON yang valid di mana struktur luar adalah daftar dan setiap elemen adalah data untuk catatan. Dalam setiap catatan, `Features` poin kunci ke array nilai fitur, dan `Label` poin-poin kunci ke label kebenaran dasar. Dataset disediakan untuk pekerjaan SageMaker Clarify dengan input `dataset` pemrosesan.
```
[
{"Features":[25,0,2850,2],"Label":0},
{"Features":[36,0,6585,0],"Label":1},
{"Features":[22,1,1759,1],"Label":1},
{"Features":[48,0,3446,1],"Label":0},
...
]
```
Bagian berikut menunjukkan cara menghitung metrik bias pra-pelatihan dan pasca-pelatihan, nilai SHAP, dan plot ketergantungan sebagian (PDPs) yang menunjukkan pentingnya fitur untuk kumpulan data dalam format JSON Lines.
#### Hitung metrik bias pra-pelatihan
Tentukan label, fitur, format, dan metode untuk mengukur metrik bias pra-pelatihan untuk `Gender` nilai. `0` Dalam contoh berikut, `headers` parameter memberikan nama fitur terlebih dahulu. Nama label diberikan terakhir. Untuk dataset JSON, header terakhir adalah header label.
`features`Parameter diatur ke JMESPath ekspresi yang mengekstrak array atau matriks 2D. Setiap baris dalam matriks ini harus berisi daftar `Features` untuk setiap catatan. `label`Parameter diatur ke JMESPath ekspresi yang mengekstrak daftar label kebenaran dasar. Setiap elemen dalam daftar ini harus berisi label untuk catatan.
Gunakan nama facet untuk menentukan atribut sensitif, sebagai berikut.
```
{
"dataset_type": "application/json",
"headers": ["Age","Gender","Income","Occupation","Target"],
"label": "[*].Label",
"features": "[*].Features",
"label_values_or_threshold": [1],
"facet": [
{
"name_or_index": "Gender",
"value_or_threshold": [0]
}
],
"methods": {
"pre_training_bias": {
"methods": "all"
}
}
}
```
#### Hitung semua metrik bias
Anda harus memiliki model terlatih untuk menghitung metrik bias pasca-pelatihan. Contoh kode berikut adalah dari model klasifikasi biner yang mengeluarkan data JSON dalam format contoh. Dalam contoh, setiap elemen di bawah `predictions` adalah output prediksi untuk catatan. Kode contoh berisi kunci`predicted_label`, yang menunjuk ke label yang diprediksi, dan `probability` poin-poin kunci ke nilai probabilitas.
```
{
"predictions": [
{"predicted_label":0,"probability":0.028986845165491},
{"predicted_label":1,"probability":0.825382471084594},
...
]
}
```
Anda dapat menerapkan model ke titik akhir SageMaker AI bernama. `your_endpoint`
Dalam contoh berikut, parameter `content_type` dan tidak `accept_type` diatur. Oleh karena itu, `content_type` dan `accept_type` secara otomatis diatur untuk menggunakan nilai parameter`dataset_type`, yaitu`application/json`. Pekerjaan pemrosesan SageMaker Clarify kemudian menggunakan `content_template` parameter untuk menyusun input model.
Dalam contoh berikut, input model disusun dengan mengganti `$records` placeholder dengan array catatan. Kemudian, `record_template` parameter menyusun struktur JSON setiap record dan menggantikan `$features` placeholder dengan array fitur masing-masing record.
Contoh konfigurasi analisis berikut menginstruksikan pekerjaan pemrosesan SageMaker Clarify untuk menghitung semua metrik bias yang mungkin untuk kumpulan data dan model.
```
{
"dataset_type": "application/json",
"headers": ["Age","Gender","Income","Occupation","Target"],
"label": "[*].Label",
"features": "[*].Features",
"label_values_or_threshold": [1],
"facet": [
{
"name_or_index": "Gender",
"value_or_threshold": [0]
}
],
"methods": {
"pre_training_bias": {
"methods": "all"
},
"post_training_bias": {
"methods": "all"
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"content_template": "$records",
"record_template": "{\"Features\":$features}",
"label": "predictions[*].predicted_label"
}
}
```
#### Hitung nilai SHAP
Anda tidak perlu menentukan label untuk analisis SHAP. Dalam contoh berikut, `headers` parameter tidak ditentukan. Oleh karena itu, pekerjaan pemrosesan SageMaker Clarify akan menghasilkan placeholder menggunakan nama generik seperti `column_0` atau `column_1` untuk header fitur, dan `label0` untuk header label. Anda dapat menentukan nilai untuk `headers` dan `label` untuk a untuk meningkatkan keterbacaan hasil analisis.
Dalam contoh konfigurasi berikut, parameter probabilitas diatur ke JMESPath ekspresi yang mengekstrak probabilitas dari setiap prediksi untuk setiap catatan. Berikut ini adalah contoh untuk menghitung nilai SHAP.
```
{
"dataset_type": "application/json",
"features": "[*].Features",
"methods": {
"shap": {
"num_clusters": 1
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"content_template": "$records",
"record_template": "{\"Features\":$features}",
"probability": "predictions[*].probability"
}
}
```
#### Hitung plot ketergantungan paral () PDPs
Contoh berikut menunjukkan kepada Anda cara melihat kepentingan fitur di PDPs. Dalam contoh, header fitur tidak disediakan. Oleh karena itu, `features` parameter `pdp` metode harus menggunakan indeks berbasis nol untuk merujuk ke lokasi kolom fitur. `grid_resolution`Parameter membagi rentang nilai fitur ke dalam `10` ember.
Bersama-sama, parameter dalam contoh berikut menginstruksikan pekerjaan pemrosesan SageMaker Clarify untuk menghasilkan laporan yang berisi grafik PDP `Income` dengan `10` segmen pada sumbu x. Sumbu y menunjukkan dampak marjinal `Income` pada prediksi.
Contoh konfigurasi berikut menunjukkan bagaimana melihat pentingnya `Income` on PDPs.
```
{
"dataset_type": "application/json",
"features": "[*].Features",
"methods": {
"pdp": {
"features": [2],
"grid_resolution": 10
},
"report": {
"name": "report"
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"content_template": "$records",
"record_template": "{\"Features\":$features}",
"probability": "predictions[*].probability"
}
}
```
#### Hitung metrik bias dan kepentingan fitur
Anda dapat menggabungkan semua metode konfigurasi sebelumnya ke dalam satu file konfigurasi analisis dan menghitung semuanya dengan satu pekerjaan. Contoh berikut menunjukkan konfigurasi analisis dengan semua langkah digabungkan.
Dalam contoh ini, `probability` parameter diatur. Karena analisis bias membutuhkan label yang diprediksi, `probability_threshold` parameter diatur ke`0.5`, yang digunakan untuk mengubah skor probabilitas menjadi label biner. Dalam contoh ini, `top_k_features` parameter `pdp` metode diatur ke`2`. Ini menginstruksikan tugas pemrosesan SageMaker Clarify PDPs untuk menghitung `2` fitur teratas dengan nilai SHAP global terbesar.
```
{
"dataset_type": "application/json",
"headers": ["Age","Gender","Income","Occupation","Target"],
"label": "[*].Label",
"features": "[*].Features",
"probability_threshold": 0.5,
"label_values_or_threshold": [1],
"facet": [
{
"name_or_index": "Gender",
"value_or_threshold": [0]
}
],
"methods": {
"pre_training_bias": {
"methods": "all"
},
"post_training_bias": {
"methods": "all"
},
"shap": {
"num_clusters": 1
},
"pdp": {
"top_k_features": 2,
"grid_resolution": 10
},
"report": {
"name": "report"
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"content_template": "$records",
"record_template": "{\"Features\":$features}",
"probability": "predictions[*].probability"
}
}
```
### Konfigurasi analisis untuk penjelasan pemrosesan bahasa alami
Contoh berikut menunjukkan file konfigurasi analisis untuk fitur komputasi yang penting untuk pemrosesan bahasa alami (NLP). Dalam contoh ini, kumpulan data yang masuk adalah kumpulan data tabular dalam format CSV, dengan satu kolom label biner dan dua kolom fitur, sebagai berikut. Dataset disediakan untuk pekerjaan SageMaker Clarify dengan parameter input `dataset` pemrosesan.
```
0,2,"They taste gross"
1,3,"Flavor needs work"
1,5,"Taste is awful"
0,1,"The worst"
...
```
Dalam contoh ini, model klasifikasi biner dilatih pada dataset sebelumnya. Model menerima data CSV, dan menghasilkan skor tunggal antara `0` dan`1`, sebagai berikut.
```
0.491656005382537
0.569582343101501
...
```
Model ini digunakan untuk membuat model SageMaker AI bernama “your\$1model”. Konfigurasi analisis berikut menunjukkan cara menjalankan analisis penjelasan berdasarkan token menggunakan model dan dataset. `text_config`Parameter mengaktifkan analisis penjelasan NLP. `granularity`Parameter menunjukkan bahwa analisis harus mengurai token.
Dalam bahasa Inggris, setiap token adalah sebuah kata. Contoh berikut juga menunjukkan cara menyediakan instance “baseline” SHAP di tempat menggunakan rata-rata “Rating” 4. Token topeng khusus “[MASK]” digunakan untuk mengganti token (kata) di “Komentar”. Contoh ini juga menggunakan tipe instance titik akhir GPU untuk mempercepat inferensi.
```
{
"dataset_type": "text/csv",
"headers": ["Target","Rating","Comments"]
"label": "Target",
"methods": {
"shap": {
"text_config": {
"granularity": "token",
"language": "english"
}
"baseline": [[4,"[MASK]"]],
}
},
"predictor": {
"model_name": "your_nlp_model",
"initial_instance_count": 1,
"instance_type": "ml.g4dn.xlarge"
}
}
```
### Konfigurasi analisis untuk penjelasan visi komputer
Contoh berikut menunjukkan analisis konfigurasi fitur komputasi file yang penting untuk visi komputer. Dalam contoh ini, dataset input terdiri dari gambar JPEG. Dataset disediakan untuk pekerjaan SageMaker Clarify dengan parameter input `dataset` pemrosesan. Contoh menunjukkan cara mengkonfigurasi analisis penjelasan menggunakan model klasifikasi SageMaker gambar. Dalam contoh, model bernama`your_cv_ic_model`, telah dilatih untuk mengklasifikasikan hewan pada gambar JPEG input.
```
{
"dataset_type": "application/x-image",
"methods": {
"shap": {
"image_config": {
"model_type": "IMAGE_CLASSIFICATION",
"num_segments": 20,
"segment_compactness": 10
}
},
"report": {
"name": "report"
}
},
"predictor": {
"model_name": "your_cv_ic_model",
"initial_instance_count": 1,
"instance_type": "ml.p2.xlarge",
"label_headers": ["bird","cat","dog"]
}
}
```
Untuk informasi lebih lanjut tentang klasifikasi gambar, lihat[Klasifikasi Gambar - MXNet](image-classification.md).
Dalam contoh ini, [model deteksi objek SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/object-detection.html), `your_cv_od_model` dilatih pada gambar JPEG yang sama untuk mengidentifikasi hewan pada mereka. Contoh berikut menunjukkan cara mengkonfigurasi analisis penjelasan untuk model deteksi objek.
```
{
"dataset_type": "application/x-image",
"probability_threshold": 0.5,
"methods": {
"shap": {
"image_config": {
"model_type": "OBJECT_DETECTION",
"max_objects": 3,
"context": 1.0,
"iou_threshold": 0.5,
"num_segments": 20,
"segment_compactness": 10
}
},
"report": {
"name": "report"
}
},
"predictor": {
"model_name": "your_cv_od_model",
"initial_instance_count": 1,
"instance_type": "ml.p2.xlarge",
"label_headers": ["bird","cat","dog"]
}
}
```
### Konfigurasi analisis untuk penjelasan model perkiraan deret waktu
Contoh berikut menunjukkan file konfigurasi analisis untuk pentingnya fitur komputasi untuk deret waktu (TS). Dalam contoh ini, kumpulan data yang masuk adalah kumpulan data deret waktu dalam format JSON dengan serangkaian fitur kovariat dinamis dan statis. Dataset disediakan untuk pekerjaan SageMaker Clarify oleh parameter input pemrosesan dataset. `dataset_uri`
```
[
{
"item_id": "item1",
"timestamp": "2019-09-11",
"target_value": 47650.3,
"dynamic_feature_1": 0.4576,
"dynamic_feature_2": 0.2164,
"dynamic_feature_3": 0.1906,
"static_feature_1": 3,
"static_feature_2": 4
},
{
"item_id": "item1",
"timestamp": "2019-09-12",
"target_value": 47380.3,
"dynamic_feature_1": 0.4839,
"dynamic_feature_2": 0.2274,
"dynamic_feature_3": 0.1889,
"static_feature_1": 3,
"static_feature_2": 4
},
{
"item_id": "item2",
"timestamp": "2020-04-23",
"target_value": 35601.4,
"dynamic_feature_1": 0.5264,
"dynamic_feature_2": 0.3838,
"dynamic_feature_3": 0.4604,
"static_feature_1": 1,
"static_feature_2": 2
},
]
```
Bagian berikut menjelaskan cara menghitung atribusi fitur untuk model peramalan dengan algoritme nilai Shapley asimetris untuk kumpulan data JSON.
#### Hitung penjelasan untuk model peramalan deret waktu
Contoh konfigurasi analisis berikut menampilkan opsi yang digunakan oleh pekerjaan untuk menghitung penjelasan untuk model peramalan deret waktu.
```
{
'dataset_type': 'application/json',
'dataset_uri': 'DATASET_URI',
'methods': {
'asymmetric_shapley_value': {
'baseline': {
"related_time_series": "zero",
"static_covariates": {
"item1": [0, 0], "item2": [0, 0]
},
"target_time_series": "zero"
},
'direction': 'chronological',
'granularity': 'fine_grained',
'num_samples': 10
},
'report': {'name': 'report', 'title': 'Analysis Report'}
},
'predictor': {
'accept_type': 'application/json',
'content_template': '{"instances": $records}',
'endpoint_name': 'ENDPOINT_NAME',
'content_type': 'application/json',
'record_template': '{
"start": $start_time,
"target": $target_time_series,
"dynamic_feat": $related_time_series,
"cat": $static_covariates
}',
'time_series_predictor_config': {'forecast': 'predictions[*].mean[:2]'}
},
'time_series_data_config': {
'dataset_format': 'timestamp_records',
'item_id': '[].item_id',
'related_time_series': ['[].dynamic_feature_1', '[].dynamic_feature_2', '[].dynamic_feature_3'],
'static_covariates': ['[].static_feature_1', '[].static_feature_2'],
'target_time_series': '[].target_value',
'timestamp': '[].timestamp'
}
}
```
##### Konfigurasi penjelasan deret waktu
Contoh sebelumnya digunakan `asymmetric_shapley_value` `methods` untuk mendefinisikan argumen penjelasan deret waktu seperti baseline, arah, granularitas, dan jumlah sampel. Nilai dasar ditetapkan untuk ketiga jenis data: deret waktu terkait, kovariat statis, dan deret waktu target. Bidang ini menginstruksikan prosesor SageMaker Clarify untuk menghitung atribusi fitur untuk satu item pada satu waktu.
##### Konfigurasi prediktor
Anda dapat sepenuhnya mengontrol struktur payload yang dikirimkan prosesor SageMaker Clarify menggunakan JMESPath sintaks. Dalam contoh sebelumnya, `predictor` konfigurasi menginstruksikan Clarify untuk menggabungkan catatan ke dalam`'{"instances": $records}'`, di mana setiap record didefinisikan dengan argumen yang diberikan dalam contoh. `record_template` Perhatikan bahwa`$start_time`,, `$target_time_series``$related_time_series`, dan `$static_covariates` merupakan token internal yang digunakan untuk memetakan nilai kumpulan data ke nilai permintaan titik akhir.
Demikian pula, atribut `forecast` di `time_series_predictor_config` digunakan untuk mengekstrak perkiraan model dari respons titik akhir. Misalnya, respons batch titik akhir Anda mungkin sebagai berikut:
```
{
"predictions": [
{"mean": [13.4, 3.6, 1.0]},
{"mean": [23.0, 4.7, 3.0]},
{"mean": [3.4, 5.6, 2.0]}
]
}
```
Misalkan Anda menentukan konfigurasi prediktor deret waktu berikut:
```
'time_series_predictor_config': {'forecast': 'predictions[*].mean[:2]'}
```
Nilai perkiraan diuraikan sebagai berikut:
```
[
[13.4, 3.6],
[23.0, 4.7],
[3.4, 5.6]
]
```
##### Konfigurasi data
Gunakan `time_series_data_config` atribut untuk menginstruksikan prosesor SageMaker Clarify agar mengurai data dengan benar dari data yang diteruskan sebagai URI S3. `dataset_uri`
# Panduan Kompatibilitas Format Data
Panduan ini menjelaskan tipe format data yang kompatibel dengan pekerjaan pemrosesan SageMaker Clarify. Jenis format data yang didukung mencakup ekstensi file, struktur data, dan persyaratan atau batasan khusus untuk kumpulan data tabular, gambar, dan deret waktu. Panduan ini juga menunjukkan cara memeriksa apakah kumpulan data Anda sesuai dengan persyaratan ini.
Pada tingkat tinggi, pekerjaan pemrosesan SageMaker Clarify mengikuti model input-proses-output untuk menghitung metrik bias dan atribusi fitur. Lihat contoh berikut untuk detailnya.
Masukan untuk pekerjaan pemrosesan SageMaker Clarify terdiri dari yang berikut:
+ Dataset yang akan dianalisis.
+ Konfigurasi analisis. Untuk informasi selengkapnya tentang cara mengonfigurasi analisis, lihat[File Konfigurasi Analisis](clarify-processing-job-configure-analysis.md).
Selama tahap pemrosesan, SageMaker Clarify menghitung metrik bias dan atribusi fitur. Pekerjaan pemrosesan Clarify menyelesaikan langkah-langkah berikut di backend: SageMaker
+ Pekerjaan pemrosesan SageMaker Clarify mem-parsing konfigurasi analisis Anda dan memuat **kumpulan data** Anda.
+ Untuk menghitung metrik bias pasca-pelatihan dan atribusi fitur, pekerjaan memerlukan prediksi model dari model Anda. **Pekerjaan pemrosesan SageMaker Clarify membuat serial data Anda dan mengirimkannya sebagai **permintaan** ke model Anda yang diterapkan pada titik akhir inferensi real-time SageMaker AI.** Setelah itu, pekerjaan pemrosesan SageMaker Clarify mengekstrak prediksi dari **respons**.
+ Pekerjaan pemrosesan SageMaker Clarify melakukan analisis bias dan penjelasan, dan kemudian menghasilkan hasilnya.
Untuk informasi selengkapnya, lihat [Bagaimana SageMaker Memperjelas Pekerjaan Pemrosesan Pekerjaan](clarify-configure-processing-jobs.md#clarify-processing-job-configure-how-it-works).
Parameter yang Anda gunakan untuk menentukan format data bergantung pada di mana data digunakan dalam aliran pemrosesan sebagai berikut:
+ Untuk **dataset input**, gunakan `dataset_type` parameter untuk menentukan format atau tipe MIME.
+ Untuk **permintaan** ke titik akhir, gunakan `content_type` parameter untuk menentukan format.
+ Untuk **respons** dari titik akhir, gunakan `accept_type` parameter untuk menentukan format.
Dataset input, permintaan, dan respons ke dan dari titik akhir tidak memerlukan format yang sama. Misalnya, Anda dapat menggunakan dataset Parket dengan payload **permintaan** CSV dan payload **respons** JSON Lines dengan kondisi berikut.
+ Analisis Anda dikonfigurasi dengan benar.
+ Model Anda mendukung format permintaan dan respons.
**catatan**
Jika `accept_type` disediakan `content_type` atau tidak, maka kontainer SageMaker Clarify menyimpulkan `content_type` dan`accept_type`.
**Topics**
+ [Data tabular](clarify-processing-job-data-format-tabular.md)
+ [Persyaratan data gambar](clarify-processing-job-data-format-image.md)
+ [Data deret waktu](clarify-processing-job-data-format-time-series.md)
# Data tabular
Data tabular mengacu pada data yang dapat dimuat ke dalam bingkai data dua dimensi. Dalam bingkai, setiap baris mewakili catatan, dan setiap catatan memiliki satu atau lebih kolom. Nilai dalam setiap sel bingkai data dapat berupa tipe data numerik, kategoris, atau teks.
## Prasyarat kumpulan data tabel
Sebelum analisis, dataset Anda seharusnya memiliki langkah-langkah pra-pemrosesan yang diperlukan yang sudah diterapkan. Ini termasuk pembersihan data atau rekayasa fitur.
Anda dapat menyediakan satu atau beberapa kumpulan data. Jika Anda menyediakan beberapa kumpulan data, gunakan yang berikut ini untuk mengidentifikasinya ke pekerjaan pemrosesan SageMaker Clarify.
+ Gunakan konfigurasi [ProcessingInput](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProcessingInput.html)bernama `dataset` atau analisis `dataset_uri` untuk menentukan kumpulan data utama. Untuk informasi selengkapnya`dataset_uri`, lihat daftar parameter di[File Konfigurasi Analisis](clarify-processing-job-configure-analysis.md).
+ Gunakan `baseline` parameter yang disediakan dalam file konfigurasi analisis. Dataset dasar diperlukan untuk analisis SHAP. Untuk informasi selengkapnya tentang file konfigurasi analisis, termasuk contoh, lihat[File Konfigurasi Analisis](clarify-processing-job-configure-analysis.md).
Tabel berikut mencantumkan format data yang didukung, ekstensi file, dan tipe MIME.
| Format data | Ekstensi file | Tipe MIME |
| --- | --- | --- |
| CSV | csv | `text/csv` |
| Garis JSON | jsonl | `application/jsonlines` |
| JSON | json | `application/json` |
| Parquet | parquet | “aplikasi/x-parket” |
Bagian berikut menunjukkan contoh kumpulan data tabular dalam format CSV, JSON Lines, dan Apache Parquet.
### Prasyarat kumpulan data tabel dalam format CSV
Pekerjaan pemrosesan SageMaker Clarify dirancang untuk memuat file data CSV dalam dialek [csv.excel](https://docs.python.org/3/library/csv.html#csv.excel). Namun, ini cukup fleksibel untuk mendukung terminator baris lainnya, termasuk `\n` dan`\r`.
Untuk kompatibilitas, semua file data CSV yang disediakan untuk pekerjaan pemrosesan SageMaker Clarify harus dikodekan dalam UTF-8.
Jika dataset Anda tidak berisi baris header, lakukan hal berikut:
+ Atur label konfigurasi analisis ke indeks`0`. Ini berarti bahwa kolom pertama adalah label kebenaran dasar.
+ Jika parameter `headers` diatur, atur `label` ke header kolom label untuk menunjukkan lokasi kolom label. Semua kolom lainnya ditetapkan sebagai fitur.
Berikut ini adalah contoh dari dataset yang tidak berisi baris header.
```
1,5,2.8,2.538,This is a good product
0,1,0.79,0.475,Bad shopping experience
...
```
Jika data Anda berisi baris header, atur parameter `label` ke indeks`0`. Untuk menunjukkan lokasi kolom label, gunakan header label kebenaran dasar`Label`. Semua kolom lainnya ditetapkan sebagai fitur.
Berikut ini adalah contoh dari dataset yang berisi baris header.
```
Label,Rating,A12,A13,Comments
1,5,2.8,2.538,This is a good product
0,1,0.79,0.475,Bad shopping experience
...
```
### Prasyarat kumpulan data tabel dalam format JSON
JSON adalah format fleksibel untuk mewakili data terstruktur yang berisi tingkat kompleksitas apa pun. Dukungan SageMaker Clarify untuk JSON tidak terbatas pada format tertentu dan dengan demikian memungkinkan format data yang lebih fleksibel dibandingkan dengan kumpulan data dalam format CSV atau JSON Lines. Panduan ini menunjukkan cara mengatur konfigurasi analisis untuk data tabular dalam format JSON.
**catatan**
Untuk memastikan kompatibilitas, semua file data JSON yang disediakan untuk pekerjaan pemrosesan SageMaker Clarify harus dikodekan dalam UTF-8.
Berikut ini adalah contoh data input dengan catatan yang berisi kunci tingkat atas, daftar fitur, dan label.
```
[
{"features":[1,5,2.8,2.538,"This is a good product"],"label":1},
{"features":[0,1,0.79,0.475,"Bad shopping experience"],"label":0},
...
]
```
Contoh analisis konfigurasi untuk contoh dataset input sebelumnya harus menetapkan parameter berikut:
+ `label`Parameter harus menggunakan [JMESPath](https://jmespath.org/)ekspresi `[*].label` untuk mengekstrak label kebenaran dasar untuk setiap catatan dalam kumpulan data. JMESPath Ekspresi harus menghasilkan daftar label di mana label ke-i sesuai dengan catatan ke-i.
+ `features`Parameter harus menggunakan JMESPath ekspresi `[*].features` untuk mengekstrak array fitur untuk setiap record dalam dataset. JMESPath Ekspresi harus menghasilkan array 2D atau matriks di mana baris ke-i berisi nilai fitur yang sesuai dengan catatan ke-i.
Berikut ini adalah contoh data masukan dengan catatan yang berisi kunci tingkat atas dan kunci bersarang yang berisi daftar fitur dan label untuk setiap rekaman.
```
{
"data": [
{"features":[1,5,2.8,2.538,"This is a good product"],"label":1}},
{"features":[0,1,0.79,0.475,"Bad shopping experience"],"label":0}}
]
}
```
Contoh analisis konfigurasi untuk contoh dataset input sebelumnya harus menetapkan parameter berikut:
+ `label`Parameter menggunakan [JMESPath](https://jmespath.org/)ekspresi `data[*].label` untuk mengekstrak label kebenaran dasar untuk setiap catatan dalam kumpulan data. JMESPath Ekspresi harus menghasilkan daftar label di mana label i th adalah untuk catatan ke-i.
+ `features`Parameter menggunakan JMESPath ekspresi `data[*].features` untuk mengekstrak array fitur, untuk setiap catatan dalam dataset. JMESPath Ekspresi harus menghasilkan array 2D atau matriks di mana baris ke-i berisi nilai fitur untuk catatan ke-i.
### Prasyarat kumpulan data tabel dalam format JSON Lines
JSON Lines adalah format teks untuk mewakili data terstruktur di mana setiap baris adalah objek JSON yang valid. Saat ini pekerjaan pemrosesan SageMaker Clarify hanya mendukung SageMaker AI Dense Format JSON Lines. Agar sesuai dengan format yang diperlukan, semua fitur catatan harus terdaftar dalam satu array JSON. Untuk informasi lebih lanjut tentang JSON Lines, lihat[Format permintaan JSONLINES](cdf-inference.md#cm-jsonlines).
**catatan**
Semua file data JSON Lines yang disediakan untuk pekerjaan pemrosesan SageMaker Clarify harus dikodekan dalam UTF-8 untuk memastikan kompatibilitas.
Berikut ini adalah contoh cara mengatur konfigurasi analisis untuk catatan yang berisi **kunci tingkat atas** dan **daftar** elemen.
```
{"features":[1,5,2.8,2.538,"This is a good product"],"label":1}
{"features":[0,1,0.79,0.475,"Bad shopping experience"],"label":0}
...
```
Analisis konfigurasi untuk contoh kumpulan data sebelumnya harus menetapkan parameter sebagai berikut:
+ Untuk menunjukkan lokasi label kebenaran dasar, parameter `label` harus diatur ke JMESPath ekspresi`label`.
+ Untuk menunjukkan lokasi array fitur, parameter `features` harus diatur ke JMESPath ekspresi`features`.
Berikut ini adalah contoh cara mengatur konfigurasi analisis untuk catatan yang berisi **kunci tingkat atas dan kunci** **bersarang** yang berisi **daftar elemen**.
```
{"data":{"features":[1,5,2.8,2.538,"This is a good product"],"label":1}}
{"data":{"features":[0,1,0.79,0.475,"Bad shopping experience"],"label":0}}
...
```
Analisis konfigurasi untuk contoh kumpulan data sebelumnya harus menetapkan parameter sebagai berikut:
+ Parameter `label` harus diatur ke JMESPath ekspresi `data.label` untuk menunjukkan lokasi label kebenaran dasar.
+ Parameter `features` harus diatur `data.features` ke JMESPath ekspresi untuk menunjukkan lokasi array fitur.
### Prasyarat kumpulan data tabel dalam format Parket
[Parket](https://parquet.apache.org/) adalah format data biner berorientasi kolom. Saat ini, SageMaker pekerjaan pemrosesan Clarify mendukung pemuatan file data Parket hanya ketika jumlah instance pemrosesan. `1`
Karena pekerjaan pemrosesan SageMaker Klarifikasi tidak mendukung permintaan titik akhir atau respons titik akhir dalam format Parket, Anda harus menentukan format data permintaan titik akhir dengan menyetel parameter konfigurasi analisis `content_type` ke format yang didukung. Untuk informasi selengkapnya, lihat `content_type` di [File Konfigurasi Analisis](clarify-processing-job-configure-analysis.md).
Data Parket harus memiliki nama kolom yang diformat sebagai string. Gunakan `label` parameter konfigurasi analisis untuk mengatur nama kolom label untuk menunjukkan lokasi label kebenaran dasar. Semua kolom lainnya ditetapkan sebagai fitur.
# Permintaan titik akhir untuk data tabular
Untuk mendapatkan prediksi model untuk analisis bias pasca-pelatihan dan analisis kepentingan fitur, SageMaker Clarify pekerjaan pemrosesan membuat serial data tabular menjadi byte dan mengirimkannya ke titik akhir inferensi sebagai muatan permintaan. Data tabular ini bersumber dari dataset input, atau dihasilkan. Jika itu adalah data sintetis, itu dihasilkan oleh penjelasan untuk analisis SHAP atau analisis PDP.
Format data payload permintaan harus ditentukan oleh `content_type` parameter konfigurasi analisis. Jika parameter tidak disediakan, pekerjaan pemrosesan SageMaker Clarify akan menggunakan nilai `dataset_type` parameter sebagai jenis konten. Untuk informasi lebih lanjut tentang `content_type` atau`dataset_type`, lihat[File Konfigurasi Analisis](clarify-processing-job-configure-analysis.md).
Bagian berikut menunjukkan contoh permintaan titik akhir dalam format CSV dan JSON Lines.
## Permintaan titik akhir dalam format CSV
Pekerjaan pemrosesan SageMaker Clarify dapat membuat serial data ke format CSV (tipe MIME:). `text/csv` Tabel berikut menunjukkan contoh muatan permintaan serial.
| Muatan permintaan titik akhir (representasi string) | Komentar |
| --- | --- |
| '1,2,3,4' | Rekaman tunggal (empat fitur numerik). |
| '1,2,3,4\$1n5,6,7,8' | Dua catatan, dipisahkan oleh jeda baris '\$1n'. |
| “Ini adalah produk yang bagus”, 5' | Rekaman tunggal (fitur teks dan fitur numerik). |
| '"Ini adalah produk yang bagus” ,5\$1n“Pengalaman belanja yang buruk”, 1 ' | Dua catatan. |
## Permintaan titik akhir dalam format JSON Lines
Pekerjaan pemrosesan SageMaker Clarify dapat membuat serial data ke format padat SageMaker AI JSON Lines (tipe MIME:). `application/jsonlines` Untuk informasi lebih lanjut tentang JSON Lines, lihat[Format permintaan JSONLINES](cdf-inference.md#cm-jsonlines).
Untuk mengubah data tabular menjadi data JSON, berikan string template ke parameter konfigurasi `content_template` analisis. Untuk informasi lebih lanjut tentang `content_template`, lihat [File Konfigurasi Analisis](clarify-processing-job-configure-analysis.md). Tabel berikut menunjukkan contoh muatan permintaan JSON Lines serial.
| Muatan permintaan titik akhir (representasi string) | Komentar |
| --- | --- |
| '\$1"data”: \$1"features”: [1,2,3,4]\$1\$1' | Rekor tunggal. Dalam hal ini, template terlihat seperti `'{"data":{"features":$features}}' ` dan `$features` digantikan oleh daftar fitur`[1,2,3,4]`. |
| '\$1"data”: \$1"features”: [1,2,3,4]\$1\$1\$1n\$1"data”: \$1"features”: [5,6,7,8]\$1\$1' | Dua catatan. |
| '\$1"features”: ["Ini adalah produk yang bagus” ,5]\$1' | Rekor tunggal. Dalam hal ini, template terlihat seperti `'{"features":$features}'` dan \$1features digantikan oleh daftar fitur`["This is a good product",5]`. |
| '\$1"features”: ["Ini adalah produk yang bagus” ,5]\$1\$1n\$1"features”: ["Pengalaman belanja yang buruk” ,1]\$1' | Dua catatan. |
## Permintaan titik akhir dalam format JSON
Pekerjaan pemrosesan SageMaker Clarify dapat membuat serial data ke struktur JSON arbitrer (tipe MIME:). `application/json` Untuk melakukan ini, Anda harus memberikan string template ke `content_template` parameter konfigurasi analisis. Ini digunakan oleh pekerjaan pemrosesan SageMaker Clarify untuk membangun struktur JSON luar. Anda juga harus menyediakan string template untuk`record_template`, yang digunakan untuk membangun struktur JSON untuk setiap record. Untuk informasi selengkapnya tentang `content_template` dan `record_template`, lihat [File Konfigurasi Analisis](clarify-processing-job-configure-analysis.md).
**catatan**
Karena `content_template` dan `record_template` merupakan parameter string, setiap karakter kutipan ganda (`"`) yang merupakan bagian dari struktur serial JSON harus dicatat sebagai karakter yang lolos dalam konfigurasi Anda. Misalnya, jika Anda ingin menghindari kutipan ganda di Python, Anda bisa memasukkan yang berikut untuk. `content_template`
```
"{\"data\":{\"features\":$record}}}"
```
Tabel berikut menunjukkan contoh muatan permintaan JSON serial dan `record_template` parameter yang sesuai `content_template` dan yang diperlukan untuk membangunnya.
| Muatan permintaan titik akhir (representasi string) | Komentar | content\$1template | record\$1template |
| --- | --- | --- | --- |
| '\$1"data”: \$1"features”: [1,2,3,4]\$1\$1' | Rekaman tunggal pada satu waktu. | '\$1"data”: \$1"features” :\$1record\$1\$1\$1' | “\$1 fitur” |
| '\$1"instance”: [[0, 1], [3, 4]], “nama-fitur”: ["A”, “B"]\$1' | Multi-rekaman dengan nama fitur. | '\$1"instance” :\$1records, “feature-names” :\$1feature\$1names\$1' | “\$1 fitur” |
| '[\$1"A”: 0, “B”: 1\$1, \$1"A”: 3, “B”: 4\$1]' | Multi-record dan pasangan kunci-nilai. | “\$1 catatan” | “\$1 features\$1kvp” |
| '\$1"A”: 0, “B”: 1\$1' | Rekaman tunggal pada satu waktu dan pasangan kunci-nilai. | “\$1 rekor” | “\$1 features\$1kvp” |
| '\$1"A”: 0, “bersarang”: \$1"B”: 1\$1\$1' | Atau, gunakan record\$1template verbose sepenuhnya untuk struktur arbitrer. | “\$1 rekor” | '\$1"A”: “\$1 \$1A\$1”, “bersarang”: \$1"B”: “\$1 \$1B\$1"\$1\$1' |
# Respon titik akhir untuk data tabular
Setelah pekerjaan pemrosesan SageMaker Clarify menerima respons pemanggilan titik akhir inferensi, ia mendeserialisasi muatan respons dan mengekstrak prediksi darinya. Gunakan `accept_type` parameter konfigurasi analisis untuk menentukan format data dari muatan respons. Jika tidak `accept_type` disediakan, pekerjaan pemrosesan SageMaker Clarify akan menggunakan nilai parameter content\$1type sebagai format keluaran model. Untuk informasi selengkapnya tentang `accept_type`, lihat [File Konfigurasi Analisis](clarify-processing-job-configure-analysis.md).
Prediksi dapat terdiri dari label yang diprediksi untuk analisis bias, atau nilai probabilitas (skor) untuk analisis kepentingan fitur. Dalam konfigurasi `predictor` analisis, tiga parameter berikut mengekstrak prediksi.
+ Parameter `probability` digunakan untuk menemukan nilai probabilitas (skor) dalam respons titik akhir.
+ Parameter `label` digunakan untuk menemukan label yang diprediksi dalam respons titik akhir.
+ (Opsional) Parameter `label_headers` menyediakan label yang diprediksi untuk model multiclass.
Pedoman berikut berkaitan dengan respons titik akhir dalam format CSV, JSON Lines, dan JSON.
## Respons Endpoint dalam format CSV
Jika payload respons dalam format CSV (tipe MIME:`text/csv`), tugas pemrosesan SageMaker Clarify melakukan deserialisasi setiap baris. Kemudian mengekstrak prediksi dari data deserialisasi menggunakan indeks kolom yang disediakan dalam konfigurasi analisis. Baris dalam muatan respons harus sesuai dengan catatan dalam payload permintaan.
Tabel berikut memberikan contoh data respons dalam format yang berbeda dan untuk jenis masalah yang berbeda. Data Anda dapat bervariasi dari contoh-contoh ini, selama prediksi dapat diekstraksi sesuai dengan konfigurasi analisis.
Bagian berikut menunjukkan contoh respons titik akhir dalam format CSV.
### Respons titik akhir dalam format CSV dan hanya berisi probabilitas
Tabel berikut adalah contoh respons titik akhir untuk masalah regresi dan klasifikasi biner.
| Muatan permintaan titik akhir | Muatan respons titik akhir (representasi string) |
| --- | --- |
| Rekor tunggal. | '0,6' |
| Dua catatan (menghasilkan satu baris, dibagi dengan koma). | '0,6,0,3' |
| Dua catatan (menghasilkan dua baris). | '0,6\$1n0,3' |
Untuk contoh sebelumnya, titik akhir menghasilkan nilai probabilitas tunggal (skor) dari label yang diprediksi. Untuk mengekstrak probabilitas menggunakan indeks dan menggunakannya untuk analisis kepentingan fitur, atur parameter konfigurasi analisis `probability` ke indeks kolom. `0` Probabilitas ini juga dapat digunakan untuk analisis bias jika dikonversi ke nilai biner dengan menggunakan parameter. `probability_threshold` Untuk informasi selengkapnya tentang `probability_threshold`, lihat [File Konfigurasi Analisis](clarify-processing-job-configure-analysis.md).
Tabel berikut adalah contoh respon endpoint untuk masalah multiclass.
| Muatan permintaan titik akhir | Muatan respons titik akhir (representasi string) |
| --- | --- |
| Rekaman tunggal model multiclass (tiga kelas). | '0.1,0.6,0.3' |
| Dua catatan model multiclass (tiga kelas). | '0.1,0.6,0.3\$1n0.2,0.5,0.3' |
Untuk contoh sebelumnya, titik akhir mengeluarkan daftar probabilitas (skor). Jika tidak ada indeks yang disediakan, semua nilai diekstraksi dan digunakan untuk analisis kepentingan fitur. Jika parameter konfigurasi analisis `label_headers` disediakan. Kemudian pekerjaan pemrosesan SageMaker Clarify dapat memilih tajuk label probabilitas maksimal sebagai label yang diprediksi, yang dapat digunakan untuk analisis bias. Untuk informasi selengkapnya tentang `label_headers`, lihat [File Konfigurasi Analisis](clarify-processing-job-configure-analysis.md).
### Respons titik akhir dalam format CSV dan hanya berisi label yang diprediksi
Tabel berikut adalah contoh respons titik akhir untuk masalah regresi dan klasifikasi biner.
| Muatan permintaan titik akhir | Muatan respons titik akhir (representasi string) |
| --- | --- |
| Rekaman tunggal | '1' |
| Dua catatan (hasil dalam satu baris, dibagi dengan koma) | '1,0' |
| Dua catatan (menghasilkan dua baris) | '1\$1n0' |
Untuk contoh sebelumnya, titik akhir mengeluarkan label yang diprediksi, bukan probabilitas. Atur `label` parameter `predictor` konfigurasi ke indeks kolom `0` sehingga label yang diprediksi dapat diekstraksi menggunakan indeks dan digunakan untuk analisis bias.
### Respons titik akhir dalam format CSV dan berisi label dan probabilitas yang diprediksi
Tabel berikut adalah contoh respons titik akhir untuk masalah regresi dan klasifikasi biner.
| Muatan permintaan titik akhir | Muatan respons titik akhir (representasi string) |
| --- | --- |
| Rekaman tunggal | '1,0.6' |
| Dua catatan | '1,0.6\$1n0,0.3' |
Untuk contoh sebelumnya, titik akhir mengeluarkan label yang diprediksi diikuti oleh probabilitasnya. Atur `label` parameter `predictor` konfigurasi ke indeks kolom`0`, dan atur `probability` ke indeks kolom `1` untuk mengekstrak kedua nilai parameter.
### Respons titik akhir dalam format CSV dan berisi label dan probabilitas yang diprediksi (multiclass)
Model multiclass yang dilatih oleh Amazon SageMaker Autopilot dapat dikonfigurasi untuk menampilkan representasi string dari daftar label dan probabilitas yang diprediksi. Contoh tabel berikut menunjukkan contoh respon endpoint dari model yang dikonfigurasi untuk output`predicted_label`,, `probability``labels`, dan`probabilities`.
| Muatan permintaan titik akhir | Muatan respons titik akhir (representasi string) |
| --- | --- |
| Rekaman tunggal | '"dog” ,0.6, "[\$1 'cat\$1 ',\$1 'dog\$1',\$1 'fish\$1 ']”, "[0.1, 0.6, 0.3]"' |
| Dua catatan | '"dog” ,0.6, "[\$1 'cat\$1 ',\$1 'dog\$1',\$1 'fish\$1 ']”, "[0.1, 0.6, 0.3]”\$1n“" kucing” ,0.7, [\$1 'cat\$1',\$1 'dog\$1 ',\$1 'ikan\$1']”, "[0.7, 0.2, 0.1]" ' |
Untuk contoh sebelumnya, pekerjaan pemrosesan SageMaker Clarify dapat dikonfigurasi dengan cara berikut untuk mengekstrak prediksi.
Untuk analisis bias, contoh sebelumnya dapat dikonfigurasi sebagai salah satu dari berikut ini.
+ Atur `label` parameter `predictor` konfigurasi `0` untuk mengekstrak label yang diprediksi.
+ Atur parameter `2` untuk mengekstrak label yang diprediksi, dan atur `probability` `3` untuk mengekstrak probabilitas yang sesuai. Pekerjaan pemrosesan SageMaker Clarify dapat secara otomatis menentukan label yang diprediksi dengan mengidentifikasi label dengan nilai probabilitas tertinggi. Mengacu pada contoh sebelumnya dari catatan tunggal, model memprediksi tiga label:`cat`,, dan `dog``fish`, dengan probabilitas yang sesuai dari`0.1`,, `0.6` dan. `0.3` Berdasarkan probabilitas ini, label yang diprediksi adalah`dog`, karena memiliki nilai probabilitas tertinggi. `0.6`
+ Setel `probability` `3` untuk mengekstrak probabilitas. Jika `label_headers` disediakan, maka pekerjaan pemrosesan SageMaker Clarify dapat secara otomatis menentukan label yang diprediksi dengan mengidentifikasi header label dengan nilai probabilitas tertinggi.
Untuk analisis kepentingan fitur, contoh sebelumnya dapat dikonfigurasi sebagai berikut.
+ Atur `probability` untuk `3` mengekstrak probabilitas semua label yang diprediksi. Kemudian, atribusi fitur akan dihitung untuk semua label. Jika pelanggan tidak menentukan`label_headers`, maka label yang diprediksi akan digunakan sebagai header label dalam laporan analisis.
## Respons Endpoint dalam format JSON Lines
Jika payload respons dalam format JSON Lines (tipe MIME:`application/jsonlines`), tugas pemrosesan SageMaker Clarify mendeserialisasi setiap baris sebagai JSON. Kemudian mengekstrak prediksi dari data deserialisasi menggunakan JMESPath ekspresi yang disediakan dalam konfigurasi analisis. Baris dalam muatan respons harus sesuai dengan catatan dalam payload permintaan. Tabel berikut menunjukkan contoh data respons dalam format yang berbeda. Data Anda dapat bervariasi dari contoh-contoh ini, selama prediksi dapat diekstraksi sesuai dengan konfigurasi analisis.
Bagian berikut menunjukkan contoh respons titik akhir dalam format JSON Lines.
### Respons titik akhir dalam format JSON Lines dan hanya berisi probabilitas
Tabel berikut adalah contoh respons titik akhir yang hanya menampilkan nilai probabilitas (skor).
| Muatan permintaan titik akhir | Muatan respons titik akhir (representasi string) |
| --- | --- |
| Rekaman tunggal | '\$1"skor” :0.6\$1' |
| Dua catatan | '\$1"score” :0.6\$1\$1n\$1"skor” :0.3\$1' |
Untuk contoh sebelumnya, atur parameter konfigurasi analisis `probability` ke JMESPath ekspresi “skor” untuk mengekstrak nilainya.
### Respons titik akhir dalam format JSON Lines dan hanya berisi label yang diprediksi
Tabel berikut adalah contoh respons titik akhir yang hanya menampilkan label yang diprediksi.
| Muatan permintaan titik akhir | Muatan respons titik akhir (representasi string) |
| --- | --- |
| Rekaman tunggal | '\$1"prediksi” :1\$1' |
| Dua catatan | '\$1"prediksi” :1\$1\$1n\$1"prediksi” :0\$1' |
Untuk contoh sebelumnya, atur `label` parameter konfigurasi prediktor ke JMESPath ekspresi`prediction`. Kemudian, pekerjaan pemrosesan SageMaker Clarify dapat mengekstrak label yang diprediksi untuk analisis bias. Untuk informasi selengkapnya, lihat [File Konfigurasi Analisis](clarify-processing-job-configure-analysis.md).
### Respons titik akhir dalam format JSON Lines dan berisi label dan probabilitas yang diprediksi
Tabel berikut adalah contoh respons titik akhir yang menampilkan label yang diprediksi dan skornya.
| Muatan permintaan titik akhir | Muatan respons titik akhir (representasi string) |
| --- | --- |
| Rekaman tunggal | '\$1"prediksi” :1, "skor” :0.6\$1' |
| Dua catatan | '\$1"prediksi” :1, "skor” :0.6\$1\$1n\$1"prediksi” :0, "skor” :0.3\$1' |
Untuk contoh sebelumnya, atur `label` parameter `predictor` konfigurasi ke JMESPath ekspresi “prediksi” untuk mengekstrak label yang diprediksi. Setel `probability` ke JMESPath ekspresi “skor” untuk mengekstrak probabilitas. Untuk informasi selengkapnya, lihat [File Konfigurasi Analisis](clarify-processing-job-configure-analysis.md).
### Respons titik akhir dalam format JSON Lines dan berisi label dan probabilitas yang diprediksi (multiclass)
Tabel berikut adalah contoh respons titik akhir dari model multiclass yang menghasilkan yang berikut:
+ Daftar label yang diprediksi.
+ Probabilitas, dan label prediksi yang dipilih dan probabilitasnya.
| Muatan permintaan titik akhir | Muatan respons titik akhir (representasi string) |
| --- | --- |
| Rekaman tunggal | '\$1"predicted\$1label” :"dog”, "probabilitas” :0.6, "predicted\$1labels”: ["cat”, "dog”, "fish "], "probabilities”: [0.1,0.6,0.3]\$1' |
| Dua catatan | '\$1"predicted\$1label” :"dog”, "probabilitas” :0.6, "predicted\$1labels”: ["cat”, "dog”, "fish "], "probabilities”: [0.1,0.6,0.3]\$1\$1n\$1"predicted\$1label” :"cat”, "probabilitas” :0.7, "predicted\$1labels”: ["cat”, "dog”, "ikan "], "probabilitas”: [0.7,0.2,0.1]\$1' |
Untuk contoh sebelumnya, pekerjaan pemrosesan SageMaker Clarify dapat dikonfigurasi dengan beberapa cara untuk mengekstrak prediksi.
Untuk analisis bias, contoh sebelumnya dapat dikonfigurasi sebagai **salah satu** dari berikut ini.
+ Atur `label` parameter `predictor` konfigurasi ke JMESPath ekspresi “predicted\$1label” untuk mengekstrak label yang diprediksi.
+ Setel parameter ke JMESPath ekspresi “predicted\$1labels” untuk mengekstrak label yang diprediksi. Atur `probability` ke JMESPath ekspresi “probabilitas” untuk mengekstrak probabilitas mereka. Pekerjaan SageMaker Clarify secara otomatis menentukan label yang diprediksi dengan mengidentifikasi label dengan nilai probabilitas tertinggi.
+ Atur `probability` ke JMESPath ekspresi “probabilitas” untuk mengekstrak probabilitas mereka. Jika `label_headers` disediakan, maka pekerjaan pemrosesan SageMaker Clarify dapat secara otomatis menentukan label yang diprediksi dengan mengidentifikasi label dengan nilai probabilitas tertinggi.
Untuk analisis kepentingan fitur, lakukan hal berikut.
+ Atur `probability` ke JMESPath ekspresi “probabilitas” untuk mengekstrak probabilitas mereka dari semua label yang diprediksi. Kemudian, atribusi fitur akan dihitung untuk semua label.
## Respons Endpoint dalam format JSON
Jika payload respons dalam format JSON (tipe MIME:`application/json`), tugas pemrosesan SageMaker Clarify mendeserialisasi seluruh muatan sebagai JSON. Kemudian mengekstrak prediksi dari data deserialisasi menggunakan JMESPath ekspresi yang disediakan dalam konfigurasi analisis. Catatan dalam muatan respons harus sesuai dengan catatan dalam payload permintaan.
Bagian berikut menunjukkan contoh respons titik akhir dalam format JSON. Bagian berisi tabel dengan contoh data respons dalam format yang berbeda dan untuk jenis masalah yang berbeda. Data Anda dapat bervariasi dari contoh-contoh ini, selama prediksi dapat diekstraksi sesuai dengan konfigurasi analisis.
### Respons titik akhir dalam format JSON dan hanya berisi probabilitas
Tabel berikut adalah contoh respons dari titik akhir yang hanya menampilkan nilai probabilitas (skor).
| Muatan permintaan titik akhir | Muatan respons titik akhir (representasi string) |
| --- | --- |
| Rekaman tunggal | '[0,6]' |
| Dua catatan | '[0.6,0.3]' |
Untuk contoh sebelumnya, tidak ada jeda baris dalam muatan respons. Sebagai gantinya, satu objek JSON berisi daftar skor, satu untuk setiap catatan dalam permintaan. Atur parameter konfigurasi analisis `probability` ke JMESPath ekspresi “[\$1]” untuk mengekstrak nilainya.
### Respons titik akhir dalam format JSON dan hanya berisi label yang diprediksi
Tabel berikut adalah contoh respons dari titik akhir yang hanya menampilkan label yang diprediksi.
| Muatan permintaan titik akhir | Muatan respons titik akhir (representasi string) |
| --- | --- |
| Rekaman tunggal | '\$1"predicted\$1labels”: [1]\$1' |
| Dua catatan | '\$1"predicted\$1labels”: [1,0]\$1' |
Setel `label` parameter `predictor` konfigurasi ke JMESPath ekspresi “predicted\$1labels”, dan kemudian pekerjaan pemrosesan SageMaker Clarify dapat mengekstrak label yang diprediksi untuk analisis bias.
### Respons titik akhir adalah format JSON dan berisi label dan probabilitas yang diprediksi
Tabel berikut adalah contoh respons dari titik akhir yang menampilkan label yang diprediksi dan skornya.
| Muatan permintaan titik akhir | Muatan respons titik akhir (representasi string) |
| --- | --- |
| Rekaman tunggal | '\$1"predictions”: [\$1"label” :1, "skor” :0.6\$1' |
| Dua catatan | '\$1"predictions”: [\$1"label” :1, "score” :0.6\$1, \$1"label” :0, "score” :0.3\$1]\$1' |
Untuk contoh sebelumnya, atur `label` parameter `predictor` konfigurasi ke JMESPath ekspresi “predictions [\$1] .label” untuk mengekstrak label yang diprediksi. Setel `probability` ke JMESPath ekspresi “prediksi [\$1] .score” untuk mengekstrak probabilitas.
### Respons titik akhir dalam format JSON dan berisi label dan probabilitas yang diprediksi (multiclass)
Tabel berikut adalah contoh respons dari titik akhir yang dari model multiclass yang menghasilkan yang berikut:
+ Daftar label yang diprediksi.
+ Probabilitas, dan label prediksi yang dipilih dan probabilitasnya.
| Muatan permintaan titik akhir | Muatan respons titik akhir (representasi string) |
| --- | --- |
| Rekaman tunggal | '[\$1"predicted\$1label” :"dog”, "probabilitas” :0.6, "predicted\$1labels”: ["cat”, "dog”, "fish "], "probabilities”: [0.1,0.6,0.3]\$1]' |
| Dua catatan | '[\$1"predicted\$1label” :"dog”, "probabilitas” :0.6, "predicted\$1labels”: ["cat”, "dog”, "fish "], "probabilities”: [0.1,0.6,0.3]\$1, \$1"predicted\$1label” :"cat”, "probabilitas” :0.7, "predicted\$1labels”: ["cat”, "dog”, "ikan "], "probabilitas”: [0.7,0.2,0.1]\$1]' |
Pekerjaan pemrosesan SageMaker Clarify dapat dikonfigurasi dengan beberapa cara untuk mengekstrak prediksi.
Untuk analisis bias, contoh sebelumnya dapat dikonfigurasi sebagai **salah satu** dari berikut ini.
+ Setel `label` parameter `predictor` konfigurasi ke JMESPath ekspresi “[\$1] .predicted\$1label” untuk mengekstrak label yang diprediksi.
+ Setel parameter ke JMESPath ekspresi “[\$1] .predicted\$1labels” untuk mengekstrak label yang diprediksi. Setel `probability` ke JMESPath ekspresi “[\$1] .probabilities” untuk mengekstrak probabilitasnya. Pekerjaan pemrosesan SageMaker Clarify dapat secara otomatis menentukan label yang diprediksi dengan mengidentifikasi label dengan nilai kedekatan tertinggi.
+ Setel `probability` ke JMESPath ekspresi “[\$1] .probabilities” untuk mengekstrak probabilitasnya. Jika `label_headers` disediakan, maka pekerjaan pemrosesan SageMaker Clarify dapat secara otomatis menentukan label yang diprediksi dengan mengidentifikasi label dengan nilai probabilitas tertinggi.
Untuk analisis kepentingan fitur, atur `probability` ke JMESPath ekspresi “[\$1] .probabilitas” untuk mengekstrak probabilitas mereka dari semua label yang diprediksi. Kemudian, atribusi fitur akan dihitung untuk semua label.
# Pra-periksa permintaan titik akhir dan respons untuk data tabular
Kami menyarankan Anda menerapkan model Anda ke titik akhir inferensi real-time SageMaker AI, dan mengirim permintaan ke titik akhir. Periksa permintaan dan tanggapan secara manual untuk memastikan bahwa keduanya sesuai dengan persyaratan di [Permintaan titik akhir untuk data tabular](clarify-processing-job-data-format-tabular-request.md) bagian dan [Respon titik akhir untuk data tabular](clarify-processing-job-data-format-tabular-response.md) bagian. Jika wadah model Anda mendukung permintaan batch, Anda dapat memulai dengan satu permintaan rekaman, lalu mencoba dua atau lebih catatan.
Perintah berikut menunjukkan cara meminta respons menggunakan AWS CLI. AWS CLI Ini sudah diinstal sebelumnya di instans SageMaker Studio dan SageMaker Notebook. Untuk menginstal AWS CLI, ikuti [panduan instalasi](https://aws.amazon.com/cli/) ini.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name $ENDPOINT_NAME \
--content-type $CONTENT_TYPE \
--accept $ACCEPT_TYPE \
--body $REQUEST_DATA \
$CLI_BINARY_FORMAT \
/dev/stderr 1>/dev/null
```
Parameter didefinisikan, sebagai berikut.
+ `$ENDPOINT NAME`— Nama titik akhir.
+ `$CONTENT_TYPE`— Jenis permintaan MIME (input wadah model).
+ `$ACCEPT_TYPE`— Jenis respons MIME (keluaran kontainer model).
+ `$REQUEST_DATA`— String payload yang diminta.
+ `$CLI_BINARY_FORMAT`— Format parameter antarmuka baris perintah (CLI). Untuk AWS CLI v1, parameter ini harus tetap kosong. Untuk v2, parameter ini harus diatur ke`--cli-binary-format raw-in-base64-out`.
**catatan**
AWS CLI [v2 melewati parameter biner sebagai string yang dikodekan base64 secara default.](https://docs.aws.amazon.com/cli/latest/userguide/cliv2-migration.html#cliv2-migration-binaryparam)
# AWS CLI contoh v1
Contoh di bagian sebelumnya adalah untuk AWS CLI v2. Contoh permintaan dan respons berikut ke dan dari titik akhir menggunakan AWS CLI v1.
## Permintaan dan respons titik akhir dalam format CSV
Dalam contoh kode berikut, permintaan terdiri dari satu catatan dan responsnya adalah nilai probabilitasnya.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-sagemaker-xgboost-model \
--content-type text/csv \
--accept text/csv \
--body '1,2,3,4' \
/dev/stderr 1>/dev/null
```
Dari contoh kode sebelumnya, output respons mengikuti.
```
0.6
```
Dalam contoh kode berikut, permintaan terdiri dari dua catatan, dan respons mencakup probabilitasnya, yang dipisahkan oleh koma.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-sagemaker-xgboost-model \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Dari contoh kode sebelumnya, `$'content'` ekspresi dalam `--body` memberitahu perintah untuk menafsirkan `'\n'` konten sebagai jeda baris. Output respons berikut.
```
0.6,0.3
```
Dalam contoh kode berikut, permintaan terdiri dari dua catatan, respons mencakup probabilitasnya, dipisahkan dengan jeda baris.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-1 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Dari contoh kode sebelumnya, output respons mengikuti.
```
0.6
0.3
```
Dalam contoh kode berikut, permintaan terdiri dari catatan tunggal, dan responsnya adalah nilai probabilitas dari model multiclass yang berisi tiga kelas.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-1 \
--content-type text/csv \
--accept text/csv \
--body '1,2,3,4' \
/dev/stderr 1>/dev/null
```
Dari contoh kode sebelumnya, output respons mengikuti.
```
0.1,0.6,0.3
```
Dalam contoh kode berikut, permintaan terdiri dari dua catatan, dan responsnya mencakup nilai probabilitasnya dari model multiclass yang berisi tiga kelas.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-1 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Dari contoh kode sebelumnya, output respons mengikuti.
```
0.1,0.6,0.3
0.2,0.5,0.3
```
Dalam contoh kode berikut, permintaan terdiri dari dua catatan, dan responsnya mencakup label dan probabilitas yang diprediksi.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-2 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Dari contoh kode sebelumnya, output respons mengikuti.
```
1,0.6
0,0.3
```
Dalam contoh kode berikut, permintaan terdiri dari dua catatan dan responsnya mencakup header label dan probabilitas.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-3 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Dari contoh kode sebelumnya, output respons mengikuti.
```
"['cat','dog','fish']","[0.1,0.6,0.3]"
"['cat','dog','fish']","[0.2,0.5,0.3]"
```
## Permintaan dan respons titik akhir dalam format JSON Lines
Dalam contoh kode berikut, permintaan terdiri dari satu catatan dan responsnya adalah nilai probabilitasnya.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines \
--content-type application/jsonlines \
--accept application/jsonlines \
--body '{"features":["This is a good product",5]}' \
/dev/stderr 1>/dev/null
```
Dari contoh kode sebelumnya, output respons mengikuti.
```
{"score":0.6}
```
Dalam contoh kode berikut, permintaan berisi dua catatan, dan responsnya mencakup label dan probabilitas yang diprediksi.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines-2 \
--content-type application/jsonlines \
--accept application/jsonlines \
--body $'{"features":[1,2,3,4]}\n{"features":[5,6,7,8]}' \
/dev/stderr 1>/dev/null
```
Dari contoh kode sebelumnya, output respons mengikuti.
```
{"predicted_label":1,"probability":0.6}
{"predicted_label":0,"probability":0.3}
```
Dalam contoh kode berikut, permintaan berisi dua catatan, dan responsnya mencakup header label dan probabilitas.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines-3 \
--content-type application/jsonlines \
--accept application/jsonlines \
--body $'{"data":{"features":[1,2,3,4]}}\n{"data":{"features":[5,6,7,8]}}' \
/dev/stderr 1>/dev/null
```
Dari contoh kode sebelumnya, output respons mengikuti.
```
{"predicted_labels":["cat","dog","fish"],"probabilities":[0.1,0.6,0.3]}
{"predicted_labels":["cat","dog","fish"],"probabilities":[0.2,0.5,0.3]}
```
## Permintaan dan respons titik akhir dalam format campuran
Dalam contoh kode berikut, permintaan dalam format CSV dan responsnya dalam format JSON Lines.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-in-jsonlines-out \
--content-type text/csv \
--accept application/jsonlines \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Dari contoh kode sebelumnya, output respons mengikuti.
```
{"probability":0.6}
{"probability":0.3}
```
Dalam contoh kode berikut, permintaan dalam format JSON Lines dan responsnya dalam format CSV.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines-in-csv-out \
--content-type application/jsonlines \
--accept text/csv \
--body $'{"features":[1,2,3,4]}\n{"features":[5,6,7,8]}' \
/dev/stderr 1>/dev/null
```
Dari contoh kode sebelumnya, output respons mengikuti.
```
0.6
0.3
```
Dalam contoh kode berikut, permintaan dalam format CSV dan responsnya dalam format JSON.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-in-jsonlines-out \
--content-type text/csv \
--accept application/jsonlines \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Dari contoh kode sebelumnya, output respons mengikuti.
```
{"predictions":[{"label":1,"score":0.6},{"label":0,"score":0.3}]}
```
# Persyaratan data gambar
Pekerjaan pemrosesan SageMaker Clarify memberikan dukungan untuk menjelaskan gambar. Topik ini menyediakan persyaratan format data untuk data gambar. Untuk informasi tentang memproses data gambar, lihat[Menganalisis data gambar untuk penjelasan visi komputer](clarify-processing-job-run.md#clarify-processing-job-run-cv).
Dataset gambar berisi satu atau lebih file gambar. Untuk mengidentifikasi kumpulan data input ke tugas pemrosesan SageMaker Clarify, tetapkan `dataset_uri` parameter konfigurasi [ProcessingInput](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateProcessingJob.html#sagemaker-CreateProcessingJob-request-ProcessingInputs)bernama `dataset` atau analisis ke awalan URI Amazon S3 dari file gambar Anda.
Format file gambar yang didukung dan ekstensi file tercantum dalam tabel berikut.
| Format gambar | Ekstensi file |
| --- | --- |
| JPEG | jpg, jpeg |
| PNG | png |
Atur `dataset_type` parameter konfigurasi analisis ke**application/x-image**. Karena jenisnya bukan format file gambar tertentu, `content_type` maka akan digunakan untuk menentukan format dan ekstensi file gambar.
Pekerjaan pemrosesan SageMaker Clarify memuat setiap file gambar ke [NumPyarray](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html) 3 dimensi untuk diproses lebih lanjut. Tiga dimensi termasuk tinggi, lebar, dan nilai RGB dari setiap piksel.
## Format permintaan titik akhir
Pekerjaan pemrosesan SageMaker Clarify mengubah data RGB mentah dari suatu gambar menjadi format gambar yang kompatibel, seperti JPEG. Ia melakukan ini sebelum mengirim data ke titik akhir untuk prediksi. Format gambar yang didukung adalah sebagai berikut.
| Format Data | Tipe MIME | Ekstensi file |
| --- | --- | --- |
| JPEG | `image/jpeg` | jpg, jpeg |
| PNG | `image/png` | png |
| NPY | `application/x-npy` | Semua di atas |
Tentukan format data payload permintaan dengan menggunakan parameter `content_type` konfigurasi analisis. Jika tidak `content_type` disediakan, format data default ke. `image/jpeg`
## Format respons titik akhir
Setelah menerima respons dari pemanggilan titik akhir inferensi, pekerjaan pemrosesan SageMaker Clarialisasi deserialisasi muatan respons dan kemudian mengekstrak prediksi darinya.
### Masalah klasifikasi gambar
Format data payload respon harus ditentukan oleh parameter konfigurasi analisis accept\$1type. Jika tidak `accept_type` disediakan, format data default ke. `application/json` Format yang didukung sama dengan yang dijelaskan dalam **respons Titik Akhir untuk data tabular di bagian data** tabular.
Lihat [Inferensi dengan Algoritma Klasifikasi Gambar](image-classification.md#IC-inference) contoh algoritma klasifikasi gambar bawaan SageMaker AI yang menerima satu gambar dan kemudian mengembalikan larik nilai probabilitas (skor), masing-masing untuk kelas.
Seperti yang ditunjukkan pada tabel berikut, ketika `content_type` parameter diatur ke`application/jsonlines`, responsnya adalah objek JSON.
| Muatan permintaan titik akhir | Muatan respons titik akhir (representasi string) |
| --- | --- |
| Gambar tunggal | '\$1"prediksi”: [0.1,0.6,0.3]\$1' |
Pada contoh sebelumnya, atur `probability` parameter ke JMESPath ekspresi “prediksi” untuk mengekstrak skor.
Ketika `content_type` diatur ke`application/json`, respon adalah objek JSON, seperti yang ditunjukkan pada tabel berikut.
| Muatan permintaan titik akhir | Muatan respons titik akhir (representasi string) |
| --- | --- |
| Gambar tunggal | '[0.1,0.6,0.3]' |
Pada contoh sebelumnya, atur `probability` ke JMESPath ekspresi “[\$1]” untuk mengekstrak semua elemen array. Pada contoh sebelumnya, [`0.1, 0.6, 0.3]`diekstraksi. Atau, jika Anda melewatkan pengaturan parameter `probability` konfigurasi, maka semua elemen array juga diekstraksi. Ini karena seluruh muatan dideserialisasi sebagai prediksi.
### Masalah deteksi objek
Konfigurasi analisis `accept_type` default `application/json` dan satu-satunya format yang didukung adalah Format Inferensi Deteksi Objek. Untuk informasi selengkapnya tentang format respons, lihat[Format Respons](object-detection-in-formats.md#object-detection-recordio).
Tabel berikut adalah contoh respon dari endpoint yang output array. Setiap elemen array adalah array nilai yang berisi indeks kelas, skor kepercayaan, dan koordinat kotak pembatas dari objek yang terdeteksi.
| Muatan permintaan titik akhir | Muatan respons titik akhir (representasi string) |
| --- | --- |
| Gambar tunggal (satu objek) | '[[4.0, 0,86419455409049988, 0,3088374733924866, 0,07030484080314636, 0,7110607028007507, 0,9345266819000244]]' |
| Gambar tunggal (dua objek) | '[[4.0, 0,86419455409049988, 0,3088374733924866, 0,07030484080314636, 0,7110607028007507, 0,9345266819000244], [0,0, 0,73376623392105103, 0,5714187026023865, 0,40427327156066895, 0,827075183391571, 0,9712159633636475]]' |
Tabel berikut adalah contoh respon dari endpoint yang output objek JSON dengan kunci mengacu pada array. Atur konfigurasi analisis `probability` ke “prediksi” kunci untuk mengekstrak nilai.
| Muatan permintaan titik akhir | Muatan respons titik akhir (representasi string) |
| --- | --- |
| Gambar tunggal (satu objek) | '\$1"prediksi”: [[4.0, 0.86419455409049988, 0.3088374733924866, 0.07030484080314636, 0.7110607028007507, 0.9345266819000244]]\$1' |
| Gambar tunggal (dua objek) | '\$1"prediksi”: [[4.0, 0.86419455409049988, 0.3088374733924866, 0.07030484080314636, 0.7110607028007507, 0.9345266819000244], [0.73376623392105103, 0.57141870260236023865, 0,40427327156066895, 0,827075183391571, 0,9712159633636475]]\$1' |
## Pra-periksa permintaan titik akhir dan respons untuk data gambar
Kami menyarankan Anda menerapkan model Anda ke titik akhir inferensi real-time SageMaker AI, dan mengirim permintaan ke titik akhir. Periksa permintaan dan tanggapan secara manual. Pastikan keduanya sesuai dengan persyaratan di bagian **Endpoint request for image data dan **Endpoint response for image** data** section.
Berikut ini adalah dua contoh kode yang menunjukkan cara mengirim permintaan dan memeriksa tanggapan untuk klasifikasi gambar dan masalah deteksi objek.
### Masalah klasifikasi gambar
Contoh kode berikut menginstruksikan endpoint untuk membaca file PNG dan kemudian mengklasifikasikannya.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-sagemaker-image-classification \
--content-type "image/png" \
--accept "application/json" \
--body fileb://./test.png \
/dev/stderr 1>/dev/null
```
Dari contoh kode sebelumnya, output respons mengikuti.
```
[0.1,0.6,0.3]
```
### Masalah deteksi objek
Contoh kode berikut menginstruksikan endpoint untuk membaca file JPEG dan kemudian mendeteksi objek di dalamnya.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-sagemaker-object-detection \
--content-type "image/jpg" \
--accept "application/json" \
--body fileb://./test.jpg \
/dev/stderr 1>/dev/null
```
Dari contoh kode sebelumnya, output respons mengikuti.
```
{"prediction":[[4.0, 0.86419455409049988, 0.3088374733924866, 0.07030484080314636, 0.7110607028007507, 0.9345266819000244],[0.0, 0.73376623392105103, 0.5714187026023865, 0.40427327156066895, 0.827075183391571, 0.9712159633636475],[4.0, 0.32643985450267792, 0.3677481412887573, 0.034883320331573486, 0.6318609714508057, 0.5967587828636169],[8.0, 0.22552496790885925, 0.6152569651603699, 0.5722782611846924, 0.882301390171051, 0.8985623121261597],[3.0, 0.42260299175977707, 0.019305512309074402, 0.08386176824569702, 0.39093565940856934, 0.9574796557426453]]}
```
# Data deret waktu
Data deret waktu mengacu pada data yang dapat dimuat ke dalam kerangka data tiga dimensi. Dalam bingkai, di setiap stempel waktu, setiap baris mewakili catatan target, dan setiap catatan target memiliki satu atau lebih kolom terkait. Nilai dalam setiap sel bingkai data dapat berupa tipe data numerik, kategoris, atau teks.
## Prasyarat kumpulan data deret waktu
Sebelum melakukan analisis, selesaikan langkah-langkah pra-pemrosesan yang diperlukan untuk menyiapkan data Anda, seperti pembersihan data atau rekayasa fitur. Anda dapat menyediakan satu atau beberapa kumpulan data. Jika Anda menyediakan beberapa kumpulan data, gunakan salah satu metode berikut untuk memasoknya ke pekerjaan pemrosesan SageMaker Clarify:
+ Gunakan konfigurasi [ProcessingInput](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProcessingInput.html)bernama `dataset` atau analisis `dataset_uri` untuk menentukan kumpulan data utama. Untuk informasi selengkapnya`dataset_uri`, lihat daftar parameter di[File Konfigurasi Analisis](clarify-processing-job-configure-analysis.md).
+ Gunakan `baseline` parameter yang disediakan dalam file konfigurasi analisis. Dataset dasar diperlukan untuk`static_covariates`, jika ada. Untuk informasi selengkapnya tentang file konfigurasi analisis, termasuk contoh, lihat[File Konfigurasi Analisis](clarify-processing-job-configure-analysis.md).
Tabel berikut mencantumkan format data yang didukung, ekstensi file, dan tipe MIME.
| Format data | Ekstensi file | Tipe MIME |
| --- | --- | --- |
| `item_records` | json | `application/json` |
| `timestamp_records` | json | `application/json` |
| `columns` | json | `application/json` |
JSON adalah format fleksibel yang dapat mewakili tingkat kompleksitas apa pun dalam data terstruktur Anda. Seperti yang ditunjukkan pada tabel, SageMaker Clarify mendukung format`item_records`,`timestamp_records`, dan`columns`.
## Contoh konfigurasi kumpulan data deret waktu
Bagian ini menunjukkan cara mengatur konfigurasi analisis menggunakan data deret `time_series_data_config` waktu dalam format JSON. Misalkan Anda memiliki kumpulan data dengan dua item, masing-masing dengan stempel waktu (t), deret waktu target (x), dua deret waktu terkait (r) dan dua kovariat statis (u) sebagai berikut:
t 1 = [0,1,2], t 2 = [2,3]
x 1 = [5,6,4], x 2 = [0,4]
r 1 = [0,1,0], r 2 1 = [1,1]
r 1 2 = [0,0,0], r 2 2 = [1,0]
u 1 1 = -1, u 2 1 = 0
u 1 2 = 1, u 2 2 = 2
Anda dapat menyandikan kumpulan data menggunakan tiga `time_series_data_config` cara berbeda, tergantung pada. `dataset_format` Bagian berikut menjelaskan setiap metode.
### Konfigurasi data deret waktu kapan `dataset_format` `columns`
Contoh berikut menggunakan `columns` nilai untuk`dataset_format`. File JSON berikut mewakili dataset sebelumnya.
```
{
"ids": [1, 1, 1, 2, 2],
"timestamps": [0, 1, 2, 2, 3], # t
"target_ts": [5, 6, 4, 0, 4], # x
"rts1": [0, 1, 0, 1, 1], # r1
"rts2": [0, 0, 0, 1, 0], # r2
"scv1": [-1, -1, -1, 0, 0], # u1
"scv2": [1, 1, 1, 2, 2], # u2
}
```
Perhatikan bahwa id item diulang di `ids` lapangan. Implementasi yang `time_series_data_config` benar ditunjukkan sebagai berikut:
```
"time_series_data_config": {
"item_id": "ids",
"timestamp": "timestamps",
"target_time_series": "target_ts",
"related_time_series": ["rts1", "rts2"],
"static_covariates": ["scv1", "scv2"],
"dataset_format": "columns"
}
```
### Konfigurasi data deret waktu kapan `dataset_format` `item_records`
Contoh berikut menggunakan `item_records` nilai untuk`dataset_format`. File JSON berikut mewakili dataset.
```
[
{
"id": 1,
"scv1": -1,
"scv2": 1,
"timeseries": [
{"timestamp": 0, "target_ts": 5, "rts1": 0, "rts2": 0},
{"timestamp": 1, "target_ts": 6, "rts1": 1, "rts2": 0},
{"timestamp": 2, "target_ts": 4, "rts1": 0, "rts2": 0}
]
},
{
"id": 2,
"scv1": 0,
"scv2": 2,
"timeseries": [
{"timestamp": 2, "target_ts": 0, "rts1": 1, "rts2": 1},
{"timestamp": 3, "target_ts": 4, "rts1": 1, "rts2": 0}
]
}
]
```
Setiap item direpresentasikan sebagai entri terpisah di JSON. Cuplikan berikut menunjukkan yang sesuai `time_series_data_config` (yang menggunakan JMESPath).
```
"time_series_data_config": {
"item_id": "[*].id",
"timestamp": "[*].timeseries[].timestamp",
"target_time_series": "[*].timeseries[].target_ts",
"related_time_series": ["[*].timeseries[].rts1", "[*].timeseries[].rts2"],
"static_covariates": ["[*].scv1", "[*].scv2"],
"dataset_format": "item_records"
}
```
### Konfigurasi data deret waktu kapan `dataset_format` `timestamp_record`
Contoh berikut menggunakan `timestamp_record` nilai untuk`dataset_format`. File JSON berikut mewakili dataset sebelumnya.
```
[
{"id": 1, "timestamp": 0, "target_ts": 5, "rts1": 0, "rts2": 0, "svc1": -1, "svc2": 1},
{"id": 1, "timestamp": 1, "target_ts": 6, "rts1": 1, "rts2": 0, "svc1": -1, "svc2": 1},
{"id": 1, "timestamp": 2, "target_ts": 4, "rts1": 0, "rts2": 0, "svc1": -1, "svc2": 1},
{"id": 2, "timestamp": 2, "target_ts": 0, "rts1": 1, "rts2": 1, "svc1": 0, "svc2": 2},
{"id": 2, "timestamp": 3, "target_ts": 4, "rts1": 1, "rts2": 0, "svc1": 0, "svc2": 2},
]
```
Setiap entri JSON mewakili satu stempel waktu dan sesuai dengan satu item. `time_series_data_config`Implementasinya ditunjukkan sebagai berikut:
```
{
"item_id": "[*].id",
"timestamp": "[*].timestamp",
"target_time_series": "[*].target_ts",
"related_time_series": ["[*].rts1"],
"static_covariates": ["[*].scv1"],
"dataset_format": "timestamp_records"
}
```
# Permintaan titik akhir untuk data deret waktu
Pekerjaan pemrosesan SageMaker Clarify membuat serialisasi data ke dalam struktur JSON arbitrer (dengan tipe MIME:). `application/json` Untuk melakukan ini, Anda harus memberikan string template ke `content_template` parameter konfigurasi analisis. Ini digunakan oleh pekerjaan pemrosesan SageMaker Clarify untuk membuat kueri JSON yang disediakan untuk model Anda. `content_template`berisi catatan atau beberapa catatan dari kumpulan data Anda. Anda juga harus menyediakan string template untuk`record_template`, yang digunakan untuk membangun struktur JSON dari setiap record. Catatan-catatan ini kemudian dimasukkan ke dalam`content_template`. Untuk informasi lebih lanjut tentang `content_type` atau`dataset_type`, lihat[File Konfigurasi Analisis](clarify-processing-job-configure-analysis.md).
**catatan**
Karena `content_template` dan `record_template` merupakan parameter string, setiap karakter kutipan ganda (“) yang merupakan bagian dari struktur serial JSON harus dicatat sebagai karakter yang diloloskan dalam konfigurasi Anda. Misalnya, jika Anda ingin menghindari tanda kutip ganda di Python, Anda dapat memasukkan nilai berikut untuk: `content_template`
```
'$record'
```
Tabel berikut menunjukkan contoh muatan permintaan JSON serial dan `record_template` parameter yang sesuai `content_template` dan yang diperlukan untuk membangunnya.
| Kasus penggunaan | Muatan permintaan titik akhir (representasi string) | content\$1template | record\$1template |
| --- | --- | --- | --- |
| Rekaman tunggal pada satu waktu | `{"target": [1, 2, 3],"start": "2024-01-01 01:00:00"}` | `'$record'` | `'{"start": $start_time, "target": $target_time_series}'` |
| Rekaman tunggal dengan `$related_time_series` dan `$static_covariates` | `{"target": [1, 2, 3],"start": "2024-01-01 01:00:00","dynamic_feat": [[1.0, 2.0, 3.0],[1.0, 2.0, 3.0],"cat": [0,1]}` | `'$record'` | `'{"start": $start_time, "target": $target_time_series, "dynamic_feat": $related_time_series, "cat": $static_covariates}'` |
| Multi-catatan | `{"instances": [{"target": [1, 2, 3],"start": "2024-01-01 01:00:00"}, {"target": [1, 2, 3],"start": "2024-01-01 02:00:00"}]}` | `'{"instances": $records}'` | `'{"start": $start_time, "target": $target_time_series}'` |
| Multi-record dengan `$related_time_series` dan `$static_covariates` | `{"instances": [{"target": [1, 2, 3],"start": "2024-01-01 01:00:00","dynamic_feat": [[1.0, 2.0, 3.0],[1.0, 2.0, 3.0],"cat": [0,1]}, {"target": [1, 2, 3],"start": "2024-01-01 02:00:00","dynamic_feat": [[1.0, 2.0, 3.0],[1.0, 2.0, 3.0],"cat": [0,1]}]}` | `'{"instances": $records}'` | `''{"start": $start_time, "target": $target_time_series, "dynamic_feat": $related_time_series, "cat": $static_covariates}'` |
# Respon titik akhir untuk data deret waktu
Pekerjaan pemrosesan SageMaker Clarify mendeserialisasi seluruh muatan sebagai JSON. Kemudian mengekstrak prediksi dari data deserialisasi menggunakan JMESPath ekspresi yang disediakan dalam konfigurasi analisis. Catatan dalam muatan respons harus sesuai dengan catatan dalam payload permintaan.
Tabel berikut adalah contoh respons dari titik akhir yang hanya menampilkan nilai prediksi rata-rata. Nilai yang `forecast` digunakan di `predictor` bidang dalam [konfigurasi analisis](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-processing-job-configure-analysis.html#clarify-processing-job-configure-analysis-parameters) harus disediakan sebagai JMESPath ekspresi untuk menemukan hasil prediksi untuk pekerjaan pemrosesan.
| Muatan permintaan titik akhir | Muatan respons titik akhir (representasi string) | JMESPath ekspresi untuk perkiraan dalam konfigurasi analisis |
| --- | --- | --- |
| Contoh catatan tunggal. Config harus mengekstrak prediksi `TimeSeriesModelConfig(forecast="prediction.mean")` dengan benar. | `'{"prediction": {"mean": [1, 2, 3, 4, 5]}'` | `'prediction.mean'` |
| Beberapa catatan. Respons titik akhir AWS DeepAR. | `'{"predictions": [{"mean": [1, 2, 3, 4, 5]}, {"mean": [1, 2, 3, 4, 5]}]}'` | `'predictions[*].mean'` |
# Pra-periksa permintaan titik akhir dan respons untuk data deret waktu
Anda disarankan untuk menerapkan model Anda ke titik akhir inferensi real-time SageMaker AI dan mengirim permintaan ke titik akhir. Periksa permintaan dan tanggapan secara manual untuk memastikan bahwa keduanya sesuai dengan persyaratan di [Respon titik akhir untuk data deret waktu](clarify-processing-job-data-format-time-series-response-json.md) bagian [Permintaan titik akhir untuk data deret waktu](clarify-processing-job-data-format-time-series-request-jsonlines.md) dan. Jika wadah model Anda mendukung permintaan batch, Anda dapat memulai dengan satu permintaan rekaman dan kemudian mencoba dua atau lebih catatan.
Perintah berikut menunjukkan cara meminta respons menggunakan AWS CLI. AWS CLI Ini sudah diinstal sebelumnya di instans Studio dan SageMaker Notebook. Untuk menginstal AWS CLI, ikuti [panduan instalasi](https://aws.amazon.com//cli/).
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name $ENDPOINT_NAME \
--content-type $CONTENT_TYPE \
--accept $ACCEPT_TYPE \
--body $REQUEST_DATA \
$CLI_BINARY_FORMAT \
/dev/stderr 1>/dev/null
```
Parameter didefinisikan sebagai berikut:
+ \$1 ENDPOINT NAME — Nama titik akhir.
+ \$1CONTENT\$1TYPE - Jenis MIME dari permintaan (input wadah model).
+ \$1ACCEPT\$1TYPE — Tipe MIME dari respon (model container output).
+ \$1REQUEST\$1DATA - String payload yang diminta.
+ \$1 CLI\$1BINARY\$1FORMAT — Format parameter antarmuka baris perintah (CLI). Untuk AWS CLI v1, parameter ini harus tetap kosong. Untuk v2, parameter ini harus diatur ke`--cli-binary-format raw-in-base64-out`.
**catatan**
AWS CLI v2 melewati parameter biner sebagai string yang dikodekan base64 secara default. Contoh permintaan dan respons berikut ke dan dari titik akhir menggunakan AWS CLI v1.
------
#### [ Example 1 ]
Dalam contoh kode berikut, permintaan terdiri dari satu catatan.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-json \
--content-type application/json \
--accept application/json \
--body '{"target": [1, 2, 3, 4, 5],
"start": "2024-01-01 01:00:00"}' \
/dev/stderr 1>/dev/null
```
Cuplikan berikut menunjukkan output respons yang sesuai.
```
{'predictions': {'mean': [1, 2, 3, 4, 5]}
```
------
#### [ Example 2 ]
Dalam contoh kode berikut, permintaan berisi dua catatan.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-json-2 \
--content-type application/json \
--accept application/json \
--body $'{"instances": [{"target":[1, 2, 3],
"start":"2024-01-01 01:00:00",
"dynamic_feat":[[1, 2, 3, 4, 5],
[1, 2, 3, 4, 5]]}], {"target":[1, 2, 3],
"start":"2024-01-02 01:00:00",
"dynamic_feat":[[1, 2, 3, 4, 5],
[1, 2, 3, 4, 5]]}]}' \
dev/stderr 1>/dev/null
```
Output respon adalah sebagai berikut:
```
{'predictions': [{'mean': [1, 2, 3, 4, 5]}, {'mean': [1, 2, 3, 4, 5]}]}
```
------
# Jalankan Pekerjaan Pemrosesan SageMaker Klarifikasi untuk Analisis Bias dan Penjelasan
Untuk menganalisis data dan model Anda untuk bias dan penjelasan menggunakan SageMaker Clarify, Anda harus mengonfigurasi pekerjaan pemrosesan SageMaker Clarify. Panduan ini menunjukkan cara mengonfigurasi input pekerjaan, output, sumber daya, dan konfigurasi analisis menggunakan SageMaker Python SDK API. `SageMakerClarifyProcessor`
API bertindak sebagai pembungkus tingkat tinggi dari SageMaker AI `CreateProcessingJob` API. Ini menyembunyikan banyak detail yang terlibat dalam menyiapkan pekerjaan pemrosesan SageMaker Clarify. Detail untuk menyiapkan pekerjaan termasuk mengambil URI image kontainer SageMaker Clarify dan membuat file konfigurasi analisis. Langkah-langkah berikut menunjukkan cara mengkonfigurasi, menginisialisasi, dan meluncurkan pekerjaan pemrosesan SageMaker Clarify.
**Mengonfigurasi tugas pemrosesan SageMaker Clarify menggunakan API**
1. Tentukan objek konfigurasi untuk setiap bagian dari konfigurasi pekerjaan. Porsi ini dapat mencakup yang berikut:
+ Dataset input dan lokasi output: [DataConfig](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html#sagemaker.clarify.DataConfig).
+ Model atau titik akhir yang akan dianalisis: [ModelConfig](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html#sagemaker.clarify.ModelConfig).
+ Parameter analisis bias: [BiasConfig](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html#sagemaker.clarify.BiasConfig).
+ SHapley Parameter analisis Penjelasan Aditif (SHAP):. [SHAPConfig](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html#sagemaker.clarify.SHAPConfig)
+ Parameter analisis nilai Shapley asimetris (hanya untuk deret waktu):. [AsymmetricShapleyValueConfig](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html#sagemaker.clarify.AsymmetricShapleyValueConfig)
Objek konfigurasi untuk pekerjaan pemrosesan SageMaker Clarify bervariasi untuk berbagai jenis format data dan kasus penggunaan. Contoh konfigurasi untuk data tabular dalam [CSV](#clarify-processing-job-run-tabular-csv) dan [JSON Lines](#clarify-processing-job-run-tabular-jsonlines) format, pemrosesan bahasa alami ([NLP](#clarify-processing-job-run-tabular-nlp)), [computer vision](#clarify-processing-job-run-cv) (CV), dan masalah deret waktu (TS) disediakan di bagian berikut.
1. Buat `SageMakerClarifyProcessor` objek dan inisialisasi dengan parameter yang menentukan sumber daya pekerjaan. Sumber daya ini mencakup parameter seperti jumlah instance komputasi yang akan digunakan.
Contoh kode berikut menunjukkan cara membuat `SageMakerClarifyProcessor` objek dan menginstruksikannya untuk menggunakan satu contoh `ml.c4.xlarge` komputasi untuk melakukan analisis.
```
from sagemaker import clarify
clarify_processor = clarify.SageMakerClarifyProcessor(
role=role,
instance_count=1,
instance_type='ml.c4.xlarge',
sagemaker_session=session,
)
```
1. Panggil metode run spesifik [SageMakerClarifyProcessor](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html#sagemaker.clarify.SageMakerClarifyProcessor.run)objek dengan objek konfigurasi untuk kasus penggunaan Anda untuk meluncurkan pekerjaan. Metode run ini meliputi yang berikut:
+ `run_pre_training_bias`
+ `run_post_training_bias`
+ `run_bias`
+ `run_explainability`
+ `run_bias_and_explainability`
Ini `SageMakerClarifyProcessor` menangani beberapa tugas di belakang layar. [Tugas ini termasuk mengambil SageMaker Clarify container image universal resource identifier (URI), menyusun file konfigurasi analisis berdasarkan objek konfigurasi yang disediakan, mengunggah file ke bucket Amazon S3, dan mengonfigurasi tugas pemrosesan Clarify. SageMaker ](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-processing-job-configure-parameters.html)
**Bagian yang dapat diperluas berikut menunjukkan cara menghitung **metrik, **SHAPnilai**, dan plot ketergantungan paral **pra-pelatihan** dan pasca-pelatihan** ().** PDPs Bagian menunjukkan pentingnya fitur untuk tipe data ini:
+ Kumpulan data tabel dalam format CSV atau format Garis JSON
+ Kumpulan data pemrosesan bahasa alami (NLP)
+ Kumpulan data visi komputer
Panduan untuk menjalankan pekerjaan pemrosesan SageMaker Clarify paralel dengan pelatihan terdistribusi menggunakan **Spark** mengikuti bagian yang dapat diperluas.
## Analisis data tabular dalam format CSV
Contoh berikut menunjukkan cara mengkonfigurasi analisis bias dan analisis eksplainabilitas untuk dataset tabel dalam format CSV. Dalam contoh ini, dataset yang masuk memiliki empat kolom fitur dan satu kolom label biner,. `Target` Isi dataset adalah sebagai berikut. Nilai label `1` menunjukkan hasil positif.
```
Target,Age,Gender,Income,Occupation
0,25,0,2850,2
1,36,0,6585,0
1,22,1,1759,1
0,48,0,3446,1
...
```
`DataConfig`Objek ini menentukan dataset input dan di mana untuk menyimpan output. `s3_data_input_path`Parameter dapat berupa URI file dataset atau awalan URI Amazon S3. Jika Anda memberikan awalan URI S3, tugas pemrosesan SageMaker Clarify secara rekursif mengumpulkan semua file Amazon S3 yang terletak di bawah awalan. Nilai untuk `s3_output_path` harus berupa awalan URI S3 untuk menahan hasil analisis. SageMaker AI menggunakan `s3_output_path` while compiling, dan tidak dapat mengambil nilai parameter SageMaker AI Pipeline, properti, ekspresi, atau`ExecutionVariable`, yang digunakan selama runtime. Contoh kode berikut menunjukkan cara menentukan konfigurasi data untuk dataset input sampel sebelumnya.
```
data_config = clarify.DataConfig(
s3_data_input_path=dataset_s3_uri,
dataset_type='text/csv',
headers=['Target', 'Age', 'Gender', 'Income', 'Occupation'],
label='Target',
s3_output_path=clarify_job_output_s3_uri,
)
```
### Cara menghitung semua metrik bias pra-pelatihan untuk kumpulan data CSV
Contoh kode berikut menunjukkan cara mengkonfigurasi `BiasConfig` objek untuk mengukur bias input sampel sebelumnya terhadap sampel dengan `Gender` nilai`0`.
```
bias_config = clarify.BiasConfig(
label_values_or_threshold=[1],
facet_name='Gender',
facet_values_or_threshold=[0],
)
```
Contoh kode berikut menunjukkan cara menggunakan pernyataan run untuk meluncurkan pekerjaan pemrosesan SageMaker Clarify yang menghitung semua [metrik bias pra-pelatihan](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-measure-data-bias.html) untuk kumpulan data input.
```
clarify_processor.run_pre_training_bias(
data_config=data_config,
data_bias_config=bias_config,
methods="all",
)
```
Atau, Anda dapat memilih metrik mana yang akan dihitung dengan menetapkan daftar metrik bias pra-pelatihan ke parameter metode. Misalnya, mengganti `methods="all"` dengan `methods=["CI", "DPL"]` menginstruksikan SageMaker Clarify Processor untuk menghitung hanya [Ketidakseimbangan Kelas](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-bias-metric-class-imbalance.html) dan [Perbedaan dalam Proporsi](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-data-bias-metric-true-label-imbalance.html) Label.
### Cara menghitung semua metrik bias pasca-pelatihan untuk kumpulan data CSV
Anda dapat menghitung metrik bias pra-pelatihan sebelum pelatihan. Namun, untuk menghitung [metrik bias pasca-pelatihan](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-measure-post-training-bias.html), Anda harus memiliki model yang terlatih. Contoh output berikut adalah dari model klasifikasi biner yang mengeluarkan data dalam format CSV. Dalam contoh output ini, setiap baris berisi dua kolom. Kolom pertama berisi label yang diprediksi, dan kolom kedua berisi nilai probabilitas untuk label tersebut.
```
0,0.028986845165491
1,0.825382471084594
...
```
Dalam contoh konfigurasi berikut, `ModelConfig` objek menginstruksikan pekerjaan untuk menyebarkan model SageMaker AI ke titik akhir sementara. Titik akhir menggunakan satu instance `ml.m4.xlarge` inferensi. Karena parameter `content_type` dan tidak `accept_type` diatur, mereka secara otomatis menggunakan nilai parameter`dataset_type`, yaitu`text/csv`.
```
model_config = clarify.ModelConfig(
model_name=your_model,
instance_type='ml.m4.xlarge',
instance_count=1,
)
```
Contoh konfigurasi berikut menggunakan `ModelPredictedLabelConfig` objek dengan indeks label`0`. Ini menginstruksikan pekerjaan pemrosesan SageMaker Clarify untuk menemukan label yang diprediksi di kolom pertama keluaran model. Pekerjaan Processing menggunakan pengindeksan berbasis nol dalam contoh ini.
```
predicted_label_config = clarify.ModelPredictedLabelConfig(
label=0,
)
```
Dikombinasikan dengan contoh konfigurasi sebelumnya, contoh kode berikut meluncurkan pekerjaan pemrosesan SageMaker Clarify untuk menghitung semua metrik bias pasca-pelatihan.
```
clarify_processor.run_post_training_bias(
data_config=data_config,
data_bias_config=bias_config,
model_config=model_config,
model_predicted_label_config=predicted_label_config,
methods="all",
)
```
Demikian pula, Anda dapat memilih metrik mana yang akan dihitung dengan menetapkan daftar metrik bias pasca-pelatihan ke parameter. `methods` Misalnya, ganti `methods=“all”` dengan `methods=["DPPL", "DI"]` untuk menghitung hanya [Perbedaan Proporsi Positif dalam Label yang Diprediksi](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-post-training-bias-metric-dppl.html) [dan Dampak](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-post-training-bias-metric-di.html) Berbeda.
### Cara menghitung semua metrik bias untuk kumpulan data CSV
Contoh konfigurasi berikut menunjukkan cara menjalankan semua metrik bias pra-pelatihan dan pasca-pelatihan dalam satu SageMaker Klarifikasi pekerjaan pemrosesan.
```
clarify_processor.run_bias(
data_config=data_config,
bias_config=bias_config,
model_config=model_config,
model_predicted_label_config=predicted_label_config,
pre_training_methods="all",
post_training_methods="all",
)
```
Untuk contoh buku catatan dengan petunjuk tentang cara menjalankan pekerjaan pemrosesan SageMaker Clarify di SageMaker Studio Classic untuk mendeteksi bias, lihat [Keadilan dan Keterjelasan](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-clarify/fairness_and_explainability/fairness_and_explainability.ipynb) dengan Clarify. SageMaker
### Cara menghitung SHAP nilai untuk kumpulan data CSV
SageMaker Clarify menyediakan atribusi fitur menggunakan algoritma [KernelShap](https://arxiv.org/abs/1705.07874). SHAPanalisis membutuhkan nilai probabilitas atau skor alih-alih label yang diprediksi, sehingga `ModelPredictedLabelConfig` objek ini memiliki indeks probabilitas`1`. Ini menginstruksikan pekerjaan pemrosesan SageMaker Clarify untuk mengekstrak skor probabilitas dari kolom kedua dari output model (menggunakan pengindeksan berbasis nol).
```
probability_config = clarify.ModelPredictedLabelConfig(
probability=1,
)
```
`SHAPConfig`Objek menyediakan parameter SHAP analisis. Dalam contoh ini, SHAP `baseline` parameter dihilangkan dan nilai `num_clusters` parameternya adalah. `1` Ini menginstruksikan Prosesor SageMaker Clarify untuk menghitung satu sampel SHAP dasar berdasarkan pengelompokan kumpulan data input. Jika Anda ingin memilih dataset dasar, lihat [SHAPBaselines](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-feature-attribute-shap-baselines.html) for Explainability.
```
shap_config = clarify.SHAPConfig(
num_clusters=1,
)
```
Contoh kode berikut meluncurkan pekerjaan pemrosesan SageMaker Clarify untuk menghitung nilaiSHAP.
```
clarify_processor.run_explainability(
data_config=data_config,
model_config=model_config,
model_scores=probability_config,
explainability_config=shap_config,
)
```
Untuk contoh buku catatan dengan petunjuk tentang cara menjalankan tugas pemrosesan SageMaker Clarify di SageMaker Studio Classic untuk menghitung SHAP nilai, lihat [Keadilan dan Keterjelasan](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-clarify/fairness_and_explainability/fairness_and_explainability.ipynb) dengan Clarify. SageMaker
### Cara menghitung plot ketergantungan paral (PDPs) untuk kumpulan data CSV
PDPsmenunjukkan ketergantungan respons target yang diprediksi pada satu atau lebih fitur input yang menarik sambil mempertahankan semua fitur lainnya konstan. Garis miring ke atas, atau kurva di PDP, menunjukkan bahwa hubungan antara target dan fitur input positif, dan kecuraman menunjukkan kekuatan hubungan. Garis miring ke bawah atau kurva menunjukkan bahwa jika fitur input menurun, variabel target meningkat. Secara intuitif, Anda dapat menafsirkan ketergantungan paral sebagai respons variabel target untuk setiap fitur input yang menarik.
Contoh konfigurasi berikut adalah untuk menggunakan `PDPConfig` objek untuk SageMaker menginstruksikan pekerjaan pemrosesan Clarify untuk menghitung pentingnya fitur. `Income`
```
pdp_config = clarify.PDPConfig(
features=["Income"],
grid_resolution=10,
)
```
Pada contoh sebelumnya, `grid_resolution` parameter membagi rentang nilai `Income` fitur menjadi `10` bucket. Pekerjaan pemrosesan SageMaker Clarify akan menghasilkan PDPs untuk `Income` dibagi menjadi `10` segmen pada sumbu x. Sumbu y akan menunjukkan dampak marjinal `Income` pada variabel target.
Contoh kode berikut meluncurkan pekerjaan pemrosesan SageMaker Clarify untuk menghitungPDPs.
```
clarify_processor.run_explainability(
data_config=data_config,
model_config=model_config,
model_scores=probability_config,
explainability_config=pdp_config,
)
```
Untuk contoh buku catatan dengan petunjuk tentang cara menjalankan pekerjaan pemrosesan SageMaker Clarify di SageMaker Studio Classic untuk dihitungPDPs, lihat [Explainability with SageMaker Clarify - Plot Ketergantungan Sebagian (](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-clarify/fairness_and_explainability/explainability_with_pdp.ipynb)PDP).
### Cara menghitung SHAP nilai dan kumpulan data PDPs CSV
Anda dapat menghitung kedua SHAP nilai dan PDPs dalam satu pekerjaan pemrosesan SageMaker Clarify. Dalam contoh konfigurasi berikut, `top_k_features` parameter `PDPConfig` objek baru diatur ke`2`. Ini menginstruksikan tugas pemrosesan SageMaker Clarify PDPs untuk menghitung `2` fitur yang memiliki nilai global SHAP terbesar.
```
shap_pdp_config = clarify.PDPConfig(
top_k_features=2,
grid_resolution=10,
)
```
Contoh kode berikut meluncurkan pekerjaan pemrosesan SageMaker Clarify untuk menghitung SHAP nilai dan. PDPs
```
clarify_processor.run_explainability(
data_config=data_config,
model_config=model_config,
model_scores=probability_config,
explainability_config=[shap_config, shap_pdp_config],
)
```
## Analisis data tabular dalam format JSON Lines
Contoh berikut menunjukkan cara mengonfigurasi analisis bias dan analisis eksplainabilitas untuk kumpulan data tabular dalam format padat> SageMaker AI JSON Lines. Untuk informasi selengkapnya, lihat [Format permintaan JSONLINES](cdf-inference.md#cm-jsonlines). Dalam contoh ini, dataset yang masuk memiliki data yang sama dengan bagian sebelumnya, tetapi mereka dalam format JSON Lines. Setiap baris adalah objek JSON yang valid. `Features`Poin kunci ke array nilai fitur, dan `Label` poin-poin kunci ke label kebenaran dasar.
```
{"Features":[25,0,2850,2],"Label":0}
{"Features":[36,0,6585,0],"Label":1}
{"Features":[22,1,1759,1],"Label":1}
{"Features":[48,0,3446,1],"Label":0}
...
```
Dalam contoh konfigurasi berikut, `DataConfig` objek menentukan dataset input dan tempat menyimpan output.
```
data_config = clarify.DataConfig(
s3_data_input_path=jsonl_dataset_s3_uri,
dataset_type='application/jsonlines',
headers=['Age', 'Gender', 'Income', 'Occupation', 'Target'],
label='Label',
features='Features',
s3_output_path=clarify_job_output_s3_uri,
)
```
Dalam contoh konfigurasi sebelumnya, parameter fitur diatur ke [JMESPath](https://jmespath.org/)ekspresi `Features` sehingga pekerjaan pemrosesan SageMaker Clarify dapat mengekstrak array fitur dari setiap catatan. `label`Parameter diatur ke JMESPath ekspresi `Label` sehingga pekerjaan pemrosesan SageMaker Clarify dapat mengekstrak label kebenaran dasar dari setiap rekaman. `s3_data_input_path`Parameter dapat berupa URI file dataset atau awalan URI Amazon S3. Jika Anda memberikan awalan URI S3, pekerjaan pemrosesan SageMaker Clarify secara rekursif mengumpulkan semua file S3 yang terletak di bawah awalan. Nilai untuk `s3_output_path` harus berupa awalan URI S3 untuk menahan hasil analisis. SageMaker AI menggunakan `s3_output_path` while compiling, dan tidak dapat mengambil nilai parameter SageMaker AI Pipeline, properti, ekspresi, atau`ExecutionVariable`, yang digunakan selama runtime.
Anda harus memiliki model terlatih untuk menghitung metrik bias pasca-pelatihan atau kepentingan fitur. Contoh berikut adalah dari model klasifikasi biner yang mengeluarkan data JSON Lines dalam format contoh. Setiap baris output model adalah objek JSON yang valid. `predicted_label`Poin kunci untuk label yang diprediksi, dan `probability` poin-poin kunci untuk nilai probabilitas.
```
{"predicted_label":0,"probability":0.028986845165491}
{"predicted_label":1,"probability":0.825382471084594}
...
```
Dalam contoh konfigurasi berikut, `ModelConfig` objek menginstruksikan pekerjaan pemrosesan SageMaker Clarify untuk menerapkan model SageMaker AI ke titik akhir sementara. Titik akhir menggunakan satu instance `ml.m4.xlarge` inferensi.
```
model_config = clarify.ModelConfig(
model_name=your_model,
instance_type='ml.m4.xlarge',
instance_count=1,
content_template='{"Features":$features}',
)
```
Dalam contoh konfigurasi sebelumnya, parameter `content_type` dan tidak `accept_type` diatur. Oleh karena itu, mereka secara otomatis menggunakan nilai `dataset_type` parameter `DataConfig` objek, yaitu`application/jsonlines`. Pekerjaan pemrosesan SageMaker Clarify menggunakan `content_template` parameter untuk menyusun input model dengan mengganti `$features` placeholder dengan array fitur.
Contoh konfigurasi berikut menunjukkan cara mengatur parameter label `ModelPredictedLabelConfig` objek ke JMESPath ekspresi`predicted_label`. Ini akan mengekstrak label yang diprediksi dari output model.
```
predicted_label_config = clarify.ModelPredictedLabelConfig(
label='predicted_label',
)
```
Contoh konfigurasi berikut menunjukkan bagaimana mengatur `probability` parameter `ModelPredictedLabelConfig` objek ke JMESPath ekspresi`probability`. Ini akan mengekstrak skor dari output model.
```
probability_config = clarify.ModelPredictedLabelConfig(
probability='probability',
)
```
Untuk menghitung metrik bias dan kepentingan fitur untuk kumpulan data dalam format JSON Lines, gunakan pernyataan run dan objek konfigurasi yang sama seperti bagian sebelumnya untuk kumpulan data CSV. Anda dapat menjalankan tugas pemrosesan SageMaker Clarify di SageMaker Studio Classic untuk mendeteksi bias dan pentingnya fitur komputasi. Untuk instruksi dan contoh buku catatan, lihat [Keadilan dan Keterjelasan dengan SageMaker Clarify (Format Garis JSON](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-clarify/fairness_and_explainability/fairness_and_explainability_jsonlines_format.ipynb)).
## Analisis data tabular untuk penjelasan NLP
SageMaker Clarify mendukung penjelasan untuk model pemrosesan bahasa alami (NLP). Penjelasan ini membantu Anda memahami bagian teks mana yang paling penting untuk prediksi model Anda. Anda dapat menjelaskan prediksi model untuk satu contoh kumpulan data input, atau prediksi model dari set data dasar. Untuk memahami dan memvisualisasikan perilaku model, Anda dapat menentukan beberapa tingkat perincian. Untuk melakukan ini, tentukan panjang segmen teks, seperti token, kalimat, paragraf.
SageMaker Klarifikasi Penjelasan NLP kompatibel dengan model klasifikasi dan regresi. Anda juga dapat menggunakan SageMaker Clarify untuk menjelaskan perilaku model Anda pada kumpulan data multi-modal yang berisi fitur teks, kategoris, atau numerik. Penjelasan NLP untuk kumpulan data multi-modal dapat membantu Anda memahami betapa pentingnya setiap fitur untuk keluaran model. SageMaker Clarify mendukung 62 bahasa dan dapat menangani teks yang mencakup beberapa bahasa.
Contoh berikut menunjukkan file konfigurasi analisis untuk fitur komputasi penting untuk NLP. Dalam contoh ini, kumpulan data yang masuk adalah kumpulan data tabular dalam format CSV, dengan satu kolom label biner dan dua kolom fitur.
```
0,2,"Flavor needs work"
1,3,"They taste good"
1,5,"The best"
0,1,"Taste is awful"
...
```
Contoh konfigurasi berikut menunjukkan cara menentukan dataset input dalam format CSV dan jalur data keluaran menggunakan objek. `DataConfig`
```
nlp_data_config = clarify.DataConfig(
s3_data_input_path=nlp_dataset_s3_uri,
dataset_type='text/csv',
headers=['Target', 'Rating', 'Comments'],
label='Target',
s3_output_path=clarify_job_output_s3_uri,
)
```
Dalam contoh konfigurasi sebelumnya, `s3_data_input_path` parameter dapat berupa URI file dataset atau awalan URI Amazon S3. Jika Anda memberikan awalan URI S3, pekerjaan pemrosesan SageMaker Clarify secara rekursif mengumpulkan semua file S3 yang terletak di bawah awalan. Nilai untuk `s3_output_path` harus berupa awalan URI S3 untuk menahan hasil analisis. SageMaker AI menggunakan `s3_output_path` while compiling, dan tidak dapat mengambil nilai parameter SageMaker AI Pipeline, properti, ekspresi, atau`ExecutionVariable`, yang digunakan selama runtime.
Contoh output berikut dibuat dari model klasifikasi biner yang dilatih pada dataset input sebelumnya. Model klasifikasi menerima data CSV, dan menghasilkan skor tunggal di antara dan. `0` `1`
```
0.491656005382537
0.569582343101501
...
```
Contoh berikut menunjukkan cara mengonfigurasi `ModelConfig` objek untuk menerapkan model SageMaker AI. Dalam contoh ini, titik akhir fana menyebarkan model. Titik akhir ini menggunakan satu instance `ml.g4dn.xlarge` inferensi yang dilengkapi dengan GPU, untuk inferensi yang dipercepat.
```
nlp_model_config = clarify.ModelConfig(
model_name=your_nlp_model_name,
instance_type='ml.g4dn.xlarge',
instance_count=1,
)
```
Contoh berikut menunjukkan bagaimana mengkonfigurasi `ModelPredictedLabelConfig` objek untuk menemukan probabilitas (skor) di kolom pertama dengan indeks`0`.
```
probability_config = clarify.ModelPredictedLabelConfig(
probability=0,
)
```
Contoh SHAP konfigurasi berikut menunjukkan cara menjalankan analisis penjelasan berdasarkan token menggunakan model dan dataset input dalam bahasa Inggris.
```
text_config = clarify.TextConfig(
language='english',
granularity='token',
)
nlp_shap_config = clarify.SHAPConfig(
baseline=[[4, '[MASK]']],
num_samples=100,
text_config=text_config,
)
```
Pada contoh sebelumnya, `TextConfig` objek mengaktifkan analisis penjelasan NLP. `granularity`Parameter menunjukkan bahwa analisis harus mengurai token. Dalam bahasa Inggris, setiap token adalah sebuah kata. Untuk bahasa lain, lihat [dokumentasi SPacy untuk tokenisasi](https://spacy.io/usage/linguistic-features#tokenization), yang digunakan SageMaker Clarify untuk pemrosesan NLP. Contoh sebelumnya juga menunjukkan cara menggunakan rata-rata `Rating` `4` untuk menetapkan instance SHAP baseline di tempat. Token topeng khusus `[MASK]` digunakan untuk mengganti token (kata) di`Comments`.
Pada contoh sebelumnya, jika instancenya`2,"Flavor needs work"`, atur baseline ke rata-rata `4` dengan `Rating` baseline berikut.
```
4, '[MASK]'
```
Pada contoh sebelumnya, SageMaker Clarify menjelaskan iterasi melalui setiap token dan menggantinya dengan mask, sebagai berikut.
```
2,"[MASK] needs work"
4,"Flavor [MASK] work"
4,"Flavor needs [MASK]"
```
Kemudian, penjelasan SageMaker Clarify akan mengirim setiap baris ke model Anda untuk prediksi. Ini agar penjelas mempelajari prediksi dengan dan tanpa kata-kata bertopeng. SageMaker Penjelasan Clarify kemudian menggunakan informasi ini untuk menghitung kontribusi setiap token.
Contoh kode berikut meluncurkan pekerjaan pemrosesan SageMaker Clarify untuk menghitung nilaiSHAP.
```
clarify_processor.run_explainability(
data_config=nlp_data_config,
model_config=nlp_model_config,
model_scores=probability_config,
explainability_config=nlp_shap_config,
)
```
Untuk contoh buku catatan dengan petunjuk tentang cara menjalankan pekerjaan pemrosesan SageMaker Clarify di SageMaker Studio Classic untuk analisis penjelasan NLP, lihat Menjelaskan Analisis Sentimen [Teks Menggunakan](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-clarify/text_explainability/text_explainability.ipynb) Klarifikasi. SageMaker
## Menganalisis data gambar untuk penjelasan visi komputer
SageMaker Clarify menghasilkan peta panas yang memberikan wawasan tentang bagaimana model visi komputer Anda mengklasifikasikan dan mendeteksi objek dalam gambar Anda.
Dalam contoh konfigurasi berikut, dataset input terdiri dari gambar JPEG.
```
cv_data_config = clarify.DataConfig(
s3_data_input_path=cv_dataset_s3_uri,
dataset_type="application/x-image",
s3_output_path=clarify_job_output_s3_uri,
)
```
Dalam contoh konfigurasi sebelumnya, `DataConfig` objek berisi `s3_data_input_path` set ke awalan Amazon S3 URI. Pekerjaan pemrosesan SageMaker Clarify secara rekursif mengumpulkan semua file gambar yang terletak di bawah awalan. `s3_data_input_path`Parameter dapat berupa URI file dataset atau awalan URI Amazon S3. Jika Anda memberikan awalan URI S3, pekerjaan pemrosesan SageMaker Clarify secara rekursif mengumpulkan semua file S3 yang terletak di bawah awalan. Nilai untuk `s3_output_path` harus berupa awalan URI S3 untuk menahan hasil analisis. SageMaker AI menggunakan `s3_output_path` while compiling, dan tidak dapat mengambil nilai parameter SageMaker AI Pipeline, properti, ekspresi, atau`ExecutionVariable`, yang digunakan selama runtime.
### Bagaimana menjelaskan model klasifikasi gambar
Pekerjaan pemrosesan SageMaker Clarify menjelaskan gambar menggunakan algoritma KernelShap, yang memperlakukan gambar sebagai kumpulan piksel super. Mengingat kumpulan data yang terdiri dari gambar, pekerjaan pemrosesan menghasilkan kumpulan data gambar di mana setiap gambar menunjukkan peta panas dari piksel super yang relevan.
Contoh konfigurasi berikut menunjukkan cara mengkonfigurasi analisis penjelasan menggunakan model klasifikasi SageMaker gambar. Untuk informasi selengkapnya, lihat [Klasifikasi Gambar - MXNet](image-classification.md).
```
ic_model_config = clarify.ModelConfig(
model_name=your_cv_ic_model,
instance_type="ml.p2.xlarge",
instance_count=1,
content_type="image/jpeg",
accept_type="application/json",
)
```
Dalam contoh konfigurasi sebelumnya, model bernama`your_cv_ic_model`, telah dilatih untuk mengklasifikasikan hewan pada gambar JPEG masukan. `ModelConfig`Objek dalam contoh sebelumnya menginstruksikan pekerjaan pemrosesan SageMaker Clarify untuk menyebarkan model SageMaker AI ke titik akhir sementara. Untuk inferensi yang dipercepat, titik akhir menggunakan satu instance `ml.p2.xlarge` inferensi yang dilengkapi dengan GPU.
Setelah gambar JPEG dikirim ke titik akhir, titik akhir mengklasifikasikannya dan mengembalikan daftar skor. Setiap skor adalah untuk kategori. `ModelPredictedLabelConfig`Objek memberikan nama setiap kategori, sebagai berikut.
```
ic_prediction_config = clarify.ModelPredictedLabelConfig(
label_headers=['bird', 'cat', 'dog'],
)
```
Contoh keluaran untuk input sebelumnya dari ['bird', 'cat', 'dog'] bisa jadi 0.3,0.6,0.1, di mana 0.3 mewakili skor kepercayaan untuk mengklasifikasikan gambar sebagai burung.
Contoh SHAP konfigurasi berikut menunjukkan cara menghasilkan penjelasan untuk masalah klasifikasi gambar. Ini menggunakan `ImageConfig` objek untuk mengaktifkan analisis.
```
ic_image_config = clarify.ImageConfig(
model_type="IMAGE_CLASSIFICATION",
num_segments=20,
segment_compactness=5,
)
ic_shap_config = clarify.SHAPConfig(
num_samples=100,
image_config=ic_image_config,
)
```
SageMaker Klarifikasi fitur ekstrak menggunakan metode [Simple Linear Iterative Clustering (SLIC)](https://scikit-image.org/docs/dev/api/skimage.segmentation.html#skimage.segmentation.slic) dari pustaka scikit-learn untuk segmentasi gambar. Contoh konfigurasi sebelumnya, `model_type` parameter, menunjukkan jenis masalah klasifikasi gambar. Parameter `num_segments` memperkirakan berapa banyak perkiraan jumlah segmen yang akan diberi label dalam gambar input. Jumlah segmen kemudian diteruskan ke `n_segments` parameter slic.
Setiap segmen gambar dianggap sebagai super-piksel, dan SHAP nilai lokal dihitung untuk setiap segmen. Parameter `segment_compactness` menentukan bentuk dan ukuran segmen gambar yang dihasilkan oleh metode scikit-image slic. Ukuran dan bentuk segmen gambar kemudian diteruskan ke `compactness` parameter slic.
Contoh kode berikut meluncurkan pekerjaan pemrosesan SageMaker Clarify untuk menghasilkan peta panas untuk gambar Anda. Nilai peta panas positif menunjukkan bahwa fitur tersebut meningkatkan skor kepercayaan dalam mendeteksi objek. Nilai negatif menunjukkan bahwa fitur tersebut menurunkan skor kepercayaan.
```
clarify_processor.run_explainability(
data_config=cv_data_config,
model_config=ic_model_config,
model_scores=ic_prediction_config,
explainability_config=ic_shap_config,
)
```
Untuk contoh buku catatan yang menggunakan Clarify untuk SageMaker mengklasifikasikan gambar dan menjelaskan klasifikasinya, lihat [Menjelaskan Klasifikasi Gambar dengan SageMaker Clarify](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-clarify/computer_vision/image_classification/explainability_image_classification.ipynb).
### Bagaimana menjelaskan model deteksi objek
Pekerjaan pemrosesan SageMaker Clarify dapat mendeteksi dan mengklasifikasikan objek dalam gambar dan kemudian memberikan penjelasan untuk objek yang terdeteksi. Proses penjelasannya adalah sebagai berikut.
1. Objek gambar pertama kali dikategorikan ke dalam salah satu kelas dalam koleksi tertentu. Misalnya, jika model deteksi objek dapat mengenali kucing, dog, dan fish, maka ketiga kelas ini ada dalam koleksi. Koleksi ini ditentukan oleh `label_headers` parameter sebagai berikut.
```
clarify.ModelPredictedLabelConfig(
label_headers=object_categories,
)
```
1. Pekerjaan pemrosesan SageMaker Clarify menghasilkan skor kepercayaan untuk setiap objek. Skor kepercayaan yang tinggi menunjukkan bahwa itu milik salah satu kelas dalam koleksi tertentu. Pekerjaan pemrosesan SageMaker Clarify juga menghasilkan koordinat kotak pembatas yang membatasi objek. Untuk informasi lebih lanjut tentang skor kepercayaan diri dan kotak pembatas, lihat[Format Respons](object-detection-in-formats.md#object-detection-recordio).
1. SageMaker Clarify kemudian memberikan penjelasan untuk mendeteksi suatu objek dalam adegan gambar. Ini menggunakan metode yang dijelaskan di bagian **Bagaimana menjelaskan model klasifikasi gambar**.
Dalam contoh konfigurasi berikut, model deteksi objek SageMaker AI `your_cv_od_model` dilatih pada gambar JPEG untuk mengidentifikasi hewan pada mereka.
```
od_model_config = clarify.ModelConfig(
model_name=your_cv_ic_model,
instance_type="ml.p2.xlarge",
instance_count=1,
content_type="image/jpeg",
accept_type="application/json",
)
```
`ModelConfig`Objek dalam contoh konfigurasi sebelumnya menginstruksikan pekerjaan pemrosesan SageMaker Clarify untuk menerapkan model SageMaker AI ke titik akhir sementara. Untuk pencitraan yang dipercepat, titik akhir ini menggunakan satu instance `ml.p2.xlarge` inferensi yang dilengkapi dengan GPU.
Dalam konfigurasi contoh berikut, `ModelPredictedLabelConfig` objek memberikan nama setiap kategori untuk klasifikasi.
```
ic_prediction_config = clarify.ModelPredictedLabelConfig(
label_headers=['bird', 'cat', 'dog'],
)
```
Contoh SHAP konfigurasi berikut menunjukkan cara menghasilkan penjelasan untuk deteksi objek.
```
od_image_config = clarify.ImageConfig(
model_type="OBJECT_DETECTION",
num_segments=20,
segment_compactness=5,
max_objects=5,
iou_threshold=0.5,
context=1.0,
)
od_shap_config = clarify.SHAPConfig(
num_samples=100,
image_config=image_config,
)
```
Dalam konfigurasi contoh sebelumnya, `ImageConfig` objek mengaktifkan analisis. `model_type`Parameter menunjukkan bahwa jenis masalah adalah deteksi objek. Untuk penjelasan rinci tentang parameter lainnya, lihat[File Konfigurasi Analisis](clarify-processing-job-configure-analysis.md).
Contoh kode berikut meluncurkan pekerjaan pemrosesan SageMaker Clarify untuk menghasilkan peta panas untuk gambar Anda. Nilai peta panas positif menunjukkan bahwa fitur tersebut meningkatkan skor kepercayaan dalam mendeteksi objek. Nilai negatif menunjukkan bahwa fitur tersebut menurunkan skor kepercayaan.
```
clarify_processor.run_explainability(
data_config=cv_data_config,
model_config=od_model_config,
model_scores=od_prediction_config,
explainability_config=od_shap_config,
)
```
Untuk contoh buku catatan yang menggunakan SageMaker Clarify untuk mendeteksi objek dalam gambar dan menjelaskan prediksinya, lihat [Menjelaskan model deteksi objek dengan Amazon SageMaker AI](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-clarify/computer_vision/object_detection/object_detection_clarify.ipynb) Clarify.
## Menganalisis penjelasan untuk model peramalan deret waktu
Contoh berikut menunjukkan cara mengonfigurasi data dalam format padat SageMaker AI JSON untuk menjelaskan model peramalan deret waktu. Untuk informasi selengkapnya tentang pemformatan JSON, lihat. [Format permintaan JSON](cdf-inference.md#cm-json)
```
[
{
"item_id": "item1",
"timestamp": "2019-09-11",
"target_value": 47650.3,
"dynamic_feature_1": 0.4576,
"dynamic_feature_2": 0.2164,
"dynamic_feature_3": 0.1906,
"static_feature_1": 3,
"static_feature_2": 4
},
{
"item_id": "item1",
"timestamp": "2019-09-12",
"target_value": 47380.3,
"dynamic_feature_1": 0.4839,
"dynamic_feature_2": 0.2274,
"dynamic_feature_3": 0.1889,
"static_feature_1": 3,
"static_feature_2": 4
},
{
"item_id": "item2",
"timestamp": "2020-04-23",
"target_value": 35601.4,
"dynamic_feature_1": 0.5264,
"dynamic_feature_2": 0.3838,
"dynamic_feature_3": 0.4604,
"static_feature_1": 1,
"static_feature_2": 2
},
]
```
### Konfigurasi data
Gunakan `TimeSeriesDataConfig` komunikasikan ke tugas penjelasan Anda cara mengurai data dengan benar dari kumpulan data input yang diteruskan, seperti yang ditunjukkan dalam konfigurasi contoh berikut:
```
time_series_data_config = clarify.TimeSeriesDataConfig(
target_time_series='[].target_value',
item_id='[].item_id',
timestamp='[].timestamp',
related_time_series=['[].dynamic_feature_1', '[].dynamic_feature_2', '[].dynamic_feature_3'],
static_covariates=['[].static_feature_1', '[].static_feature_2'],
dataset_format='timestamp_records',
)
```
### Konfigurasi nilai Shapley asimetris
Gunakan `AsymmetricShapleyValueConfig` untuk mendefinisikan argumen untuk analisis penjelasan model peramalan deret waktu seperti garis dasar, arah, granularitas, dan jumlah sampel. Nilai dasar ditetapkan untuk ketiga jenis data: deret waktu terkait, kovariat statis, dan deret waktu target. `AsymmetricShapleyValueConfig`Konfigurasi menginformasikan prosesor SageMaker Clarify cara menghitung atribusi fitur untuk satu item pada satu waktu. Konfigurasi berikut menunjukkan contoh definisi`AsymmetricShapleyValueConfig`.
```
asymmetric_shapley_value_config = AsymmetricShapleyValueConfig(
direction="chronological",
granularity="fine-grained",
num_samples=10,
baseline={
"related_time_series": "zero",
"static_covariates": {
"item1": [0, 0], "item2": [0, 0]
},
"target_time_series": "zero"
},
)
```
Nilai yang Anda berikan `AsymmetricShapleyValueConfig` diteruskan ke konfigurasi analisis sebagai entri `methods` dengan kunci`asymmetric_shapley_value`.
### Konfigurasi model
Anda dapat mengontrol struktur muatan yang dikirim dari prosesor SageMaker Clarify. Dalam contoh kode berikut, objek `ModelConfig` konfigurasi mengarahkan pekerjaan penjelasan perkiraan deret waktu ke agregat catatan menggunakan JMESPath sintaks ke dalam`'{"instances": $records}'`, di mana struktur setiap catatan didefinisikan dengan record\$1template berikut. `'{"start": $start_time, "target": $target_time_series, "dynamic_feat": $related_time_series, "cat": $static_covariates}'` Perhatikan bahwa`$start_time`,, `$target_time_series``$related_time_series`, dan `$static_covariates` merupakan token internal yang digunakan untuk memetakan nilai kumpulan data ke nilai permintaan titik akhir.
```
model_config = clarify.ModelConfig(
model_name=your_model,
instance_type='ml.m4.xlarge',
instance_count=1,
record_template='{"start": $start_time, "target": $target_time_series, "dynamic_feat": $related_time_series, "cat": $static_covariates}',
content_template='{"instances": $records}',,
time_series_model_config=TimeSeriesModelConfig(
forecast={'forecast': 'predictions[*].mean[:2]'}
)
)
```
Demikian pula, atribut `forecast` di`TimeSeriesModelConfig`, diteruskan ke konfigurasi analisis dengan kunci`time_series_predictor_config`, digunakan untuk mengekstrak perkiraan model dari respons titik akhir. Misalnya, contoh respons batch titik akhir bisa menjadi sebagai berikut:
```
{
"predictions": [
{"mean": [13.4, 3.6, 1.0]},
{"mean": [23.0, 4.7, 3.0]},
{"mean": [3.4, 5.6, 2.0]}
]
}
```
Jika JMESPath ekspresi yang disediakan `forecast` adalah \$1'predictions [\$1] .mean [:2] '\$1\$1, nilai perkiraan diuraikan sebagai berikut:
```
[[13.4, 3.6], [23.0, 4.7], [3.4, 5.6]]
```
## Cara menjalankan pekerjaan pemrosesan SageMaker Clarify paralel
Saat bekerja dengan kumpulan data besar, Anda dapat menggunakan [Apache Spark](https://spark.apache.org/) untuk meningkatkan kecepatan pekerjaan pemrosesan Clarify Anda SageMaker . Spark adalah mesin analitik terpadu untuk pemrosesan data skala besar. Bila Anda meminta lebih dari satu instance per prosesor SageMaker Clarify, SageMaker Clarify menggunakan kemampuan komputasi terdistribusi dari Spark.
Contoh konfigurasi berikut menunjukkan cara menggunakan `SageMakerClarifyProcessor` untuk membuat prosesor SageMaker Clarify dengan instance `5` komputasi. Untuk menjalankan pekerjaan apa pun yang terkait dengan`SageMakerClarifyProcessor`, SageMaker Klarifikasi menggunakan pemrosesan terdistribusi Spark.
```
from sagemaker import clarify
spark_clarify_processor = clarify.SageMakerClarifyProcessor(
role=role,
instance_count=5,
instance_type='ml.c5.xlarge',
)
```
Jika Anda menyetel `save_local_shap_values` parameter [SHAPConfig](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html#sagemaker.clarify.SHAPConfig)ke`True`, tugas pemrosesan SageMaker Clarify akan menyimpan SHAP nilai lokal sebagai beberapa file bagian di lokasi keluaran pekerjaan.
Untuk mengaitkan SHAP nilai lokal ke instance dataset input, gunakan `joinsource` parameter. `DataConfig` Jika Anda menambahkan lebih banyak instance komputasi, kami sarankan Anda juga meningkatkan `instance_count` dari [ModelConfig](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html#sagemaker.clarify.ModelConfig)untuk titik akhir fana. Ini mencegah permintaan inferensi bersamaan pekerja Spark dari membanjiri titik akhir. Secara khusus, kami menyarankan Anda menggunakan one-to-one rasio endpoint-to-processing instance.
# Hasil Analisis
Setelah tugas pemrosesan SageMaker Clarify selesai, Anda dapat mengunduh file keluaran untuk memeriksanya, atau Anda dapat memvisualisasikan hasilnya di SageMaker Studio Classic. Topik berikut menjelaskan hasil analisis yang dihasilkan SageMaker Clarify, seperti skema dan laporan yang dihasilkan oleh analisis bias, analisis SHAP, analisis penjelasan visi komputer, dan analisis plot ketergantungan paral (). PDPs Jika analisis konfigurasi berisi parameter untuk menghitung beberapa analisis, maka hasilnya dikumpulkan menjadi satu analisis dan satu file laporan.
Direktori SageMaker Clarify processing job output berisi file-file berikut:
+ `analysis.json`— File yang berisi metrik bias dan kepentingan fitur dalam format JSON.
+ `report.ipynb`— Notebook statis yang berisi kode untuk membantu Anda memvisualisasikan metrik bias dan kepentingan fitur.
+ `explanations_shap/out.csv`— Direktori yang dibuat dan berisi file yang dibuat secara otomatis berdasarkan konfigurasi analisis spesifik Anda. Misalnya, jika Anda mengaktifkan `save_local_shap_values` parameter, maka nilai SHAP lokal per instance akan disimpan ke direktori. `explanations_shap` Sebagai contoh lain, jika Anda `analysis configuration` tidak berisi nilai untuk parameter baseline SHAP, pekerjaan Clarify SageMaker menjelaskan menghitung baseline dengan mengelompokkan kumpulan data input. Kemudian menyimpan baseline yang dihasilkan ke direktori.
Untuk informasi lebih rinci, lihat bagian berikut.
**Topics**
+ [Analisis bias](#clarify-processing-job-analysis-results-bias)
+ [Analisis SHAP](#clarify-processing-job-analysis-results-shap)
+ [Analisis eksplainabilitas visi komputer (CV)](#clarify-processing-job-analysis-results-cv)
+ [Analisis plot ketergantungan sebagian (PDPs)](#clarify-processing-job-analysis-results-pdp)
+ [Nilai Shapley asimetris](#clarify-processing-job-analysis-results-asymmshap)
## Analisis bias
Amazon SageMaker Clarify menggunakan terminologi yang didokumentasikan [Amazon SageMaker Klarifikasi Persyaratan untuk Bias dan Keadilan](clarify-detect-data-bias.md#clarify-bias-and-fairness-terms) untuk membahas bias dan keadilan.
### Skema untuk file analisis
File analisis dalam format JSON dan disusun menjadi dua bagian: metrik bias pra-pelatihan dan metrik bias pasca-pelatihan. Parameter untuk metrik bias pra-pelatihan dan pasca-pelatihan adalah sebagai berikut.
+ **pre\$1training\$1bias\$1metrics — Parameter untuk metrik bias** pra-pelatihan. Untuk informasi selengkapnya, lihat [Metrik Bias Pra-pelatihan](clarify-measure-data-bias.md) dan [File Konfigurasi Analisis](clarify-processing-job-configure-analysis.md).
+ **label** — Nama label kebenaran dasar yang ditentukan oleh `label` parameter konfigurasi analisis.
+ **label\$1value\$1or\$1threshold** — String yang berisi nilai label atau interval yang ditentukan oleh parameter konfigurasi analisis. `label_values_or_threshold` Misalnya, jika nilai `1` disediakan untuk masalah klasifikasi biner, maka string akan menjadi`1`. Jika beberapa nilai `[1,2]` disediakan untuk masalah multi-kelas, maka string akan`1,2`. Jika ambang batas `40` disediakan untuk masalah regresi, maka string akan menjadi internal seperti `(40, 68]` yang `68` merupakan nilai maksimum label dalam dataset input.
+ **faset** — Bagian ini berisi beberapa pasangan kunci-nilai, di mana kunci sesuai dengan nama facet yang ditentukan oleh `name_or_index` parameter konfigurasi facet, dan nilainya adalah array objek facet. Setiap objek facet memiliki anggota berikut:
+ **value\$1or\$1threshold** — String yang berisi nilai facet atau interval yang ditentukan oleh parameter konfigurasi facet. `value_or_threshold`
+ **metrik** - Bagian ini berisi array elemen metrik bias, dan setiap elemen metrik bias memiliki atribut berikut:
+ **nama** — Nama pendek dari metrik bias. Misalnya, `CI`.
+ **deskripsi** — Nama lengkap metrik bias. Misalnya, `Class Imbalance (CI)`.
+ **nilai — Nilai** metrik bias, atau nilai nol JSON jika metrik bias tidak dihitung karena alasan tertentu. Nilai ± ∞ direpresentasikan sebagai string `∞` dan `-∞` masing-masing.
+ **error** — Pesan kesalahan opsional yang menjelaskan mengapa metrik bias tidak dihitung.
+ **post\$1training\$1bias\$1metrics — Bagian ini berisi metrik** bias pasca-pelatihan dan mengikuti tata letak dan struktur yang mirip dengan bagian pra-pelatihan. Untuk informasi selengkapnya, lihat [Data Pasca-pelatihan dan Metrik Bias Model](clarify-measure-post-training-bias.md).
Berikut ini adalah contoh konfigurasi analisis yang akan menghitung metrik bias pra-pelatihan dan pasca-pelatihan.
```
{
"version": "1.0",
"pre_training_bias_metrics": {
"label": "Target",
"label_value_or_threshold": "1",
"facets": {
"Gender": [{
"value_or_threshold": "0",
"metrics": [
{
"name": "CDDL",
"description": "Conditional Demographic Disparity in Labels (CDDL)",
"value": -0.06
},
{
"name": "CI",
"description": "Class Imbalance (CI)",
"value": 0.6
},
...
]
}]
}
},
"post_training_bias_metrics": {
"label": "Target",
"label_value_or_threshold": "1",
"facets": {
"Gender": [{
"value_or_threshold": "0",
"metrics": [
{
"name": "AD",
"description": "Accuracy Difference (AD)",
"value": -0.13
},
{
"name": "CDDPL",
"description": "Conditional Demographic Disparity in Predicted Labels (CDDPL)",
"value": 0.04
},
...
]
}]
}
}
}
```
### Laporan analisis bias
Laporan analisis bias mencakup beberapa tabel dan diagram yang berisi penjelasan dan deskripsi terperinci. Ini termasuk, tetapi tidak terbatas pada, distribusi nilai label, distribusi nilai faset, diagram kinerja model tingkat tinggi, tabel metrik bias, dan deskripsinya. Untuk informasi selengkapnya tentang metrik bias dan cara menafsirkannya, lihat [Pelajari Cara Amazon SageMaker Memperjelas Membantu Mendeteksi](https://aws.amazon.com/blogs/machine-learning/learn-how-amazon-sagemaker-clarify-helps-detect-bias/) Bias.
## Analisis SHAP
SageMaker Klarifikasi pekerjaan pemrosesan menggunakan algoritma Kernel SHAP untuk menghitung atribusi fitur. Pekerjaan pemrosesan SageMaker Clarify menghasilkan nilai SHAP lokal dan global. Ini membantu menentukan kontribusi setiap fitur terhadap prediksi model. Nilai SHAP lokal mewakili kepentingan fitur untuk setiap instance individu, sementara nilai SHAP global menggabungkan nilai SHAP lokal di semua instance dalam kumpulan data. Untuk informasi selengkapnya tentang nilai SHAP dan cara menafsirkannya, lihat. [Atribusi Fitur yang Menggunakan Nilai Shapley](clarify-shapley-values.md)
### Skema untuk file analisis SHAP
Hasil analisis SHAP global disimpan di bagian penjelasan dari file analisis, di bawah metode ini`kernel_shap`. Parameter yang berbeda dari file analisis SHAP adalah sebagai berikut:
+ **penjelasan** — Bagian dari file analisis yang berisi fitur penting hasil analisis.
+ **kernal\$1shap** — Bagian dari file analisis yang berisi hasil analisis SHAP global.
+ **global\$1shap\$1values** — Bagian dari file analisis yang berisi beberapa pasangan kunci-nilai. Setiap kunci dalam pasangan kunci-nilai mewakili nama fitur dari dataset input. Setiap nilai dalam pasangan kunci-nilai sesuai dengan nilai SHAP global fitur. Nilai SHAP global diperoleh dengan menggabungkan nilai SHAP per instance fitur menggunakan konfigurasi. `agg_method` Jika `use_logit` konfigurasi diaktifkan, maka nilainya dihitung menggunakan koefisien regresi logistik, yang dapat diartikan sebagai rasio log-odds.
+ **expected\$1value** — Prediksi rata-rata dari dataset dasar. Jika `use_logit` konfigurasi diaktifkan, maka nilainya dihitung menggunakan koefisien regresi logistik.
+ **global\$1top\$1shap\$1text** - Digunakan untuk analisis penjelasan NLP. Bagian dari file analisis yang mencakup satu set pasangan kunci-nilai. SageMaker Klarifikasi pekerjaan pemrosesan agregat nilai SHAP dari setiap token dan kemudian pilih token teratas berdasarkan nilai SHAP globalnya. `max_top_tokens`Konfigurasi mendefinisikan jumlah token yang akan dipilih.
Masing-masing token teratas yang dipilih memiliki pasangan nilai kunci. Kunci dalam pasangan kunci-nilai sesuai dengan nama fitur teks token teratas. Setiap nilai dalam pasangan kunci-nilai adalah nilai SHAP global dari token teratas. Untuk contoh pasangan `global_top_shap_text` kunci-nilai, lihat output berikut.
Contoh berikut menunjukkan output dari analisis SHAP dari dataset tabular.
```
{
"version": "1.0",
"explanations": {
"kernel_shap": {
"Target": {
"global_shap_values": {
"Age": 0.022486410860333206,
"Gender": 0.007381025261958729,
"Income": 0.006843906804137847,
"Occupation": 0.006843906804137847,
...
},
"expected_value": 0.508233428001
}
}
}
}
```
Contoh berikut menunjukkan output dari analisis SHAP dari dataset teks. Output yang sesuai dengan kolom `Comments` adalah contoh output yang dihasilkan setelah analisis fitur teks.
```
{
"version": "1.0",
"explanations": {
"kernel_shap": {
"Target": {
"global_shap_values": {
"Rating": 0.022486410860333206,
"Comments": 0.058612104851485144,
...
},
"expected_value": 0.46700941970297033,
"global_top_shap_text": {
"charming": 0.04127962903247833,
"brilliant": 0.02450240786522321,
"enjoyable": 0.024093569652715457,
...
}
}
}
}
}
```
### Skema untuk file baseline yang dihasilkan
Ketika konfigurasi dasar SHAP tidak disediakan, pekerjaan pemrosesan SageMaker Clarify menghasilkan kumpulan data dasar. SageMaker Clarify menggunakan algoritma pengelompokan berbasis jarak untuk menghasilkan dataset dasar dari cluster yang dibuat dari dataset input. Dataset dasar yang dihasilkan disimpan dalam file CSV, yang terletak di. `explanations_shap/baseline.csv` File output ini berisi baris header dan beberapa contoh berdasarkan `num_clusters` parameter yang ditentukan dalam konfigurasi analisis. Dataset dasar hanya terdiri dari kolom fitur. Contoh berikut menunjukkan garis dasar yang dibuat dengan mengelompokkan dataset input.
```
Age,Gender,Income,Occupation
35,0,2883,1
40,1,6178,2
42,0,4621,0
```
### Skema untuk nilai SHAP lokal dari analisis keterjelasan kumpulan data tabular
Untuk kumpulan data tabular, jika satu instance komputasi digunakan, tugas pemrosesan SageMaker Clarify menyimpan nilai SHAP lokal ke file CSV bernama. `explanations_shap/out.csv` Jika Anda menggunakan beberapa instance komputasi, nilai SHAP lokal disimpan ke beberapa file CSV di direktori. `explanations_shap`
File keluaran yang berisi nilai SHAP lokal memiliki baris yang berisi nilai SHAP lokal untuk setiap kolom yang ditentukan oleh header. Header mengikuti konvensi penamaan `Feature_Label` di mana nama fitur ditambahkan oleh garis bawah, diikuti dengan nama variabel target Anda.
Untuk masalah multi-kelas, nama fitur di header bervariasi terlebih dahulu, lalu label. Misalnya, dua fitur`F1, F2`, dan dua kelas `L1` dan`L2`, di header adalah`F1_L1`,, `F2_L1``F1_L2`, dan`F2_L2`. Jika konfigurasi analisis berisi nilai untuk `joinsource_name_or_index` parameter, maka kolom kunci yang digunakan dalam gabungan ditambahkan ke akhir nama header. Hal ini memungkinkan pemetaan nilai SHAP lokal ke instance dataset input. Contoh file output yang berisi nilai SHAP berikut.
```
Age_Target,Gender_Target,Income_Target,Occupation_Target
0.003937908,0.001388849,0.00242389,0.00274234
-0.0052784,0.017144491,0.004480645,-0.017144491
...
```
### Skema untuk nilai SHAP lokal dari analisis penjelasan NLP
Untuk analisis penjelasan NLP, jika satu instance komputasi digunakan, tugas pemrosesan SageMaker Clarify menyimpan nilai SHAP lokal ke file JSON Lines bernama. `explanations_shap/out.jsonl` Jika Anda menggunakan beberapa instance komputasi, nilai SHAP lokal disimpan ke beberapa file JSON Lines di direktori. `explanations_shap`
Setiap file yang berisi nilai SHAP lokal memiliki beberapa baris data, dan setiap baris adalah objek JSON yang valid. Objek JSON memiliki atribut berikut:
+ **penjelasan** — Bagian dari file analisis yang berisi array penjelasan Kernel SHAP untuk satu contoh. Setiap elemen dalam array memiliki anggota berikut:
+ **feature\$1name — Nama** header dari fitur yang disediakan oleh konfigurasi header.
+ **data\$1type - Jenis** fitur yang disimpulkan oleh pekerjaan pemrosesan Clarify. SageMaker Nilai yang valid untuk fitur teks termasuk`numerical`,`categorical`, dan `free_text` (untuk fitur teks).
+ **atribusi** — Array objek atribusi khusus fitur. Fitur teks dapat memiliki beberapa objek atribusi, masing-masing untuk unit yang ditentukan oleh `granularity` konfigurasi. Objek atribusi memiliki anggota berikut:
+ **atribusi** — Array nilai probabilitas khusus kelas.
+ **deskripsi** — (Untuk fitur teks) Deskripsi unit teks.
+ **partial\$1text** — Bagian teks yang dijelaskan oleh pekerjaan pemrosesan SageMaker Clarify.
+ **start\$1idx** — Indeks berbasis nol untuk mengidentifikasi lokasi array yang menunjukkan awal fragmen teks paral.
Berikut ini adalah contoh dari satu baris dari file nilai SHAP lokal, dipercantik untuk meningkatkan keterbacaannya.
```
{
"explanations": [
{
"feature_name": "Rating",
"data_type": "categorical",
"attributions": [
{
"attribution": [0.00342270632248735]
}
]
},
{
"feature_name": "Comments",
"data_type": "free_text",
"attributions": [
{
"attribution": [0.005260534499999983],
"description": {
"partial_text": "It's",
"start_idx": 0
}
},
{
"attribution": [0.00424190349999996],
"description": {
"partial_text": "a",
"start_idx": 5
}
},
{
"attribution": [0.010247314500000014],
"description": {
"partial_text": "good",
"start_idx": 6
}
},
{
"attribution": [0.006148907500000005],
"description": {
"partial_text": "product",
"start_idx": 10
}
}
]
}
]
}
```
### Laporan analisis SHAP
Laporan analisis SHAP menyediakan bagan batang maksimum nilai SHAP global `10` teratas. Contoh bagan berikut menunjukkan nilai SHAP untuk `4` fitur teratas.
![\[Bagan batang horizontal dari nilai SHAP global dihitung untuk variabel target dari empat fitur teratas.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/clarify/shap-chart.png)
## Analisis eksplainabilitas visi komputer (CV)
SageMaker Clarify Computer Vision Explainability mengambil kumpulan data yang terdiri dari gambar dan memperlakukan setiap gambar sebagai kumpulan piksel super. Setelah analisis, pekerjaan pemrosesan SageMaker Clarify mengeluarkan kumpulan data gambar di mana setiap gambar menunjukkan peta panas piksel super.
Contoh berikut menunjukkan tanda batas kecepatan input di sebelah kiri dan peta panas menunjukkan besarnya nilai SHAP di sebelah kanan. [Nilai SHAP ini dihitung dengan model pengenalan gambar Resnet-18 yang dilatih untuk mengenali rambu lalu lintas Jerman.](https://benchmark.ini.rub.de/gtsrb_news.html) Dataset German Traffic Sign Recognition Benchmark (GTSRB) disediakan dalam paper [Man vs. Computer: Algoritma pembelajaran mesin benchmarking](https://www.sciencedirect.com/science/article/abs/pii/S0893608012000457?via%3Dihub) untuk pengenalan rambu lalu lintas. Dalam contoh output, nilai positif yang besar menunjukkan bahwa piksel super memiliki korelasi positif yang kuat dengan prediksi model. Nilai negatif yang besar menunjukkan bahwa piksel super memiliki korelasi negatif yang kuat dengan prediksi model. Semakin besar nilai absolut dari nilai SHAP yang ditunjukkan dalam peta panas, semakin kuat hubungan antara piksel super dan prediksi model.
![\[Input gambar tanda batas kecepatan dan peta panas yang dihasilkan dari nilai SHAP dari model Resnet-18.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/clarify/shap_speed-limit-70.png)
Untuk informasi selengkapnya, lihat contoh buku catatan [Menjelaskan Klasifikasi Gambar dengan SageMaker Memperjelas dan Menjelaskan](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-clarify/computer_vision/image_classification/explainability_image_classification.ipynb) [model deteksi objek dengan Amazon](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-clarify/computer_vision/object_detection/object_detection_clarify.ipynb) Clarify. SageMaker
## Analisis plot ketergantungan sebagian (PDPs)
Plot ketergantungan sebagian menunjukkan ketergantungan respons target yang diprediksi pada serangkaian fitur input yang menarik. Ini dipinggirkan atas nilai-nilai semua fitur input lainnya dan disebut sebagai fitur pelengkap. Secara intuitif, Anda dapat menafsirkan ketergantungan sebagian sebagai respons target, yang diharapkan sebagai fungsi dari setiap fitur input yang menarik.
### Skema untuk file analisis
Nilai PDP disimpan di `explanations` bagian file analisis di bawah `pdp` metode. Parameter untuk `explanations` adalah sebagai berikut:
+ **penjelasan** — Bagian dari file analisis yang berisi fitur penting hasil analisis.
+ **PDP** — Bagian dari file analisis yang berisi array penjelasan PDP untuk satu contoh. Setiap elemen array memiliki anggota berikut:
+ **feature\$1name — Nama** header dari fitur yang disediakan oleh konfigurasi. `headers`
+ **data\$1type - Jenis** fitur yang disimpulkan oleh pekerjaan pemrosesan Clarify. SageMaker Nilai yang valid untuk `data_type` termasuk numerik dan kategoris.
+ **feature\$1values** - Berisi nilai-nilai yang ada dalam fitur. Jika yang `data_type` disimpulkan oleh SageMaker Clarify bersifat kategoris, `feature_values` berisi semua nilai unik yang dapat dimiliki fitur tersebut. Jika `data_type` disimpulkan oleh SageMaker Clarify adalah numerik, `feature_values` berisi daftar nilai pusat dari bucket yang dihasilkan. `grid_resolution`Parameter menentukan jumlah ember yang digunakan untuk mengelompokkan nilai kolom fitur.
+ **data\$1distribution** — Sebuah array persentase, di mana setiap nilai adalah persentase instance yang berisi bucket. `grid_resolution`Parameter menentukan jumlah ember. Nilai kolom fitur dikelompokkan ke dalam ember ini.
+ **model\$1predictions** — Sebuah array prediksi model, di mana setiap elemen dari array adalah array prediksi yang sesuai dengan satu kelas dalam output model.
**label\$1headers** — Header label yang disediakan oleh konfigurasi. `label_headers`
+ **kesalahan** — Pesan kesalahan yang dihasilkan jika nilai PDP tidak dihitung karena alasan tertentu. Pesan galat ini menggantikan konten yang terkandung dalam`feature_values`,`data_distributions`, dan `model_predictions` bidang.
Berikut ini adalah contoh output dari file analisis yang berisi hasil analisis PDP.
```
{
"version": "1.0",
"explanations": {
"pdp": [
{
"feature_name": "Income",
"data_type": "numerical",
"feature_values": [1046.9, 2454.7, 3862.5, 5270.2, 6678.0, 8085.9, 9493.6, 10901.5, 12309.3, 13717.1],
"data_distribution": [0.32, 0.27, 0.17, 0.1, 0.045, 0.05, 0.01, 0.015, 0.01, 0.01],
"model_predictions": [[0.69, 0.82, 0.82, 0.77, 0.77, 0.46, 0.46, 0.45, 0.41, 0.41]],
"label_headers": ["Target"]
},
...
]
}
}
```
### Laporan analisis PDP
Anda dapat membuat laporan analisis yang berisi bagan PDP untuk setiap fitur. Bagan PDP memplot `feature_values` sepanjang sumbu x, dan plot `model_predictions` sepanjang sumbu y. Untuk model multi-kelas, `model_predictions` adalah array, dan setiap elemen dari array ini sesuai dengan salah satu kelas prediksi model.
Berikut ini adalah contoh bagan PDP untuk fitur `Age` tersebut. Dalam contoh output, PDP menunjukkan jumlah nilai fitur yang dikelompokkan ke dalam ember. Jumlah ember ditentukan oleh`grid_resolution`. Ember nilai fitur diplot terhadap prediksi model. Dalam contoh ini, nilai fitur yang lebih tinggi memiliki nilai prediksi model yang sama.
![\[Bagan garis yang menunjukkan bagaimana prediksi model bervariasi terhadap feature_values titik kisi 10 unik.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/clarify/pdp-chart.png)
## Nilai Shapley asimetris
SageMaker Klarifikasi pekerjaan pemrosesan menggunakan algoritme nilai Shapley asimetris untuk menghitung atribusi penjelasan model peramalan deret waktu. Algoritma ini menentukan kontribusi fitur input pada setiap langkah waktu menuju prediksi yang diperkirakan.
### Skema untuk file analisis nilai Shapley asimetris
Hasil nilai Shapley asimetris disimpan dalam bucket Amazon S3. Anda dapat menemukan lokasi bucket ini di bagian *penjelasan* file analisis. Bagian ini berisi fitur penting hasil analisis. Parameter berikut termasuk dalam file analisis nilai Shapley asimetris.
+ **asymmetric\$1shapley\$1value** — Bagian dari file analisis yang berisi metadata tentang penjelasan hasil pekerjaan, termasuk yang berikut:
+ **explanation\$1results\$1path — Lokasi** Amazon S3 dengan hasil penjelasan
+ **arah** - Konfigurasi yang disediakan pengguna untuk nilai konfigurasi `direction`
+ **granularitas** — Konfigurasi yang disediakan pengguna untuk nilai konfigurasi `granularity`
Cuplikan berikut menunjukkan parameter yang disebutkan sebelumnya dalam file analisis contoh:
```
{
"version": "1.0",
"explanations": {
"asymmetric_shapley_value": {
"explanation_results_path": EXPLANATION_RESULTS_S3_URI,
"direction": "chronological",
"granularity": "timewise",
}
}
}
```
Bagian berikut menjelaskan bagaimana struktur hasil penjelasan tergantung pada nilai `granularity` dalam konfigurasi.
#### Granularitas mengikut waktu
Ketika `timewise` granularitas adalah output diwakili dalam struktur berikut. `scores`Nilai mewakili atribusi untuk setiap stempel waktu. `offset`Nilai mewakili prediksi model pada data dasar dan menggambarkan perilaku model ketika tidak menerima data.
Cuplikan berikut menunjukkan contoh output untuk model yang membuat prediksi untuk dua langkah waktu. Oleh karena itu, semua atribusi adalah daftar dua elemen di mana entri pertama mengacu pada langkah waktu yang diprediksi pertama.
```
{
"item_id": "item1",
"offset": [1.0, 1.2],
"explanations": [
{"timestamp": "2019-09-11 00:00:00", "scores": [0.11, 0.1]},
{"timestamp": "2019-09-12 00:00:00", "scores": [0.34, 0.2]},
{"timestamp": "2019-09-13 00:00:00", "scores": [0.45, 0.3]},
]
}
{
"item_id": "item2",
"offset": [1.0, 1.2],
"explanations": [
{"timestamp": "2019-09-11 00:00:00", "scores": [0.51, 0.35]},
{"timestamp": "2019-09-12 00:00:00", "scores": [0.14, 0.22]},
{"timestamp": "2019-09-13 00:00:00", "scores": [0.46, 0.31]},
]
}
```
#### Granularitas berbutir halus
Contoh berikut menunjukkan hasil atribusi ketika granularitas. `fine_grained` `offset`Nilai memiliki arti yang sama seperti yang dijelaskan di bagian sebelumnya. Atribusi dihitung untuk setiap fitur input pada setiap stempel waktu untuk deret waktu target dan deret waktu terkait, jika tersedia, dan untuk setiap kovariat statis, jika tersedia.
```
{
"item_id": "item1",
"offset": [1.0, 1.2],
"explanations": [
{"feature_name": "tts_feature_name_1", "timestamp": "2019-09-11 00:00:00", "scores": [0.11, 0.11]},
{"feature_name": "tts_feature_name_1", "timestamp": "2019-09-12 00:00:00", "scores": [0.34, 0.43]},
{"feature_name": "tts_feature_name_2", "timestamp": "2019-09-11 00:00:00", "scores": [0.15, 0.51]},
{"feature_name": "tts_feature_name_2", "timestamp": "2019-09-12 00:00:00", "scores": [0.81, 0.18]},
{"feature_name": "rts_feature_name_1", "timestamp": "2019-09-11 00:00:00", "scores": [0.01, 0.10]},
{"feature_name": "rts_feature_name_1", "timestamp": "2019-09-12 00:00:00", "scores": [0.14, 0.41]},
{"feature_name": "rts_feature_name_1", "timestamp": "2019-09-13 00:00:00", "scores": [0.95, 0.59]},
{"feature_name": "rts_feature_name_1", "timestamp": "2019-09-14 00:00:00", "scores": [0.95, 0.59]},
{"feature_name": "rts_feature_name_2", "timestamp": "2019-09-11 00:00:00", "scores": [0.65, 0.56]},
{"feature_name": "rts_feature_name_2", "timestamp": "2019-09-12 00:00:00", "scores": [0.43, 0.34]},
{"feature_name": "rts_feature_name_2", "timestamp": "2019-09-13 00:00:00", "scores": [0.16, 0.61]},
{"feature_name": "rts_feature_name_2", "timestamp": "2019-09-14 00:00:00", "scores": [0.95, 0.59]},
{"feature_name": "static_covariate_1", "scores": [0.6, 0.1]},
{"feature_name": "static_covariate_2", "scores": [0.1, 0.3]},
]
}
```
Untuk keduanya `timewise` dan kasus `fine-grained` penggunaan, hasilnya disimpan dalam format JSON Lines (.jsonl).
# Memecahkan Masalah SageMaker Klarifikasi Pekerjaan Pemrosesan
Jika Anda mengalami kegagalan dengan SageMaker pekerjaan pemrosesan Clarify, lihat skenario berikut untuk membantu mengidentifikasi masalah.
**catatan**
Alasan kegagalan dan pesan keluar dimaksudkan untuk berisi pesan deskriptif dan pengecualian, jika ditemui, selama dijalankan. Alasan umum untuk kesalahan adalah bahwa parameter hilang atau tidak valid. Jika Anda menemukan pesan yang tidak jelas, membingungkan, atau menyesatkan atau tidak dapat menemukan solusi, kirimkan umpan balik.
**Topics**
+ [Pekerjaan pemrosesan gagal diselesaikan](#clarify-troubleshooting-job-fails)
+ [Memproses pekerjaan terlalu lama untuk dijalankan](#clarify-troubleshooting-job-long)
+ [Memproses pekerjaan selesai tanpa hasil dan Anda mendapatkan pesan CloudWatch peringatan](#clarify-troubleshooting-no-results-and-warning)
+ [Pesan galat untuk konfigurasi analisis yang tidak valid](#clarify-troubleshooting-invalid-analysis-configuration)
+ [Perhitungan metrik bias gagal untuk beberapa atau semua metrik](#clarify-troubleshooting-bias-metric-computation-fails)
+ [Ketidakcocokan antara konfigurasi analisis dan input/output dataset/model](#clarify-troubleshooting-mismatch-analysis-config-and-data-model)
+ [Model mengembalikan 500 Kesalahan Server Internal atau kontainer kembali ke prediksi per rekaman karena kesalahan model](#clarify-troubleshooting-500-internal-server-error)
+ [Peran eksekusi tidak valid](#clarify-troubleshooting-execution-role-invalid)
+ [Gagal mengunduh data](#clarify-troubleshooting-data-download)
+ [Tidak dapat terhubung ke SageMaker AI](#clarify-troubleshooting-connection)
## Pekerjaan pemrosesan gagal diselesaikan
Jika pekerjaan pemrosesan gagal selesai, Anda dapat mencoba yang berikut:
+ Periksa log pekerjaan langsung di buku catatan tempat Anda menjalankan pekerjaan. Log pekerjaan terletak di output sel notebook tempat Anda memulai proses.
+ Periksa log pekerjaan di CloudWatch.
+ Tambahkan baris berikut di buku catatan Anda untuk menjelaskan pekerjaan pemrosesan terakhir dan cari alasan kegagalan dan pesan keluar:
+ `clarify_processor.jobs[-1].describe()`
+ Jalankan perintah berikut AWS CLI; untuk menggambarkan pekerjaan pemrosesan dan mencari alasan kegagalan dan pesan keluar:
+ `aws sagemaker describe-processing-job —processing-job-name `
## Memproses pekerjaan terlalu lama untuk dijalankan
Jika pekerjaan pemrosesan Anda terlalu lama untuk dijalankan, gunakan cara-cara berikut untuk menemukan akar masalahnya.
Periksa untuk melihat apakah konfigurasi sumber daya Anda cukup untuk menangani beban komputasi Anda. Untuk mempercepat pekerjaan Anda, coba yang berikut ini:
+ Gunakan tipe instance yang lebih besar. SageMaker Klarifikasi kueri model berulang kali, dan instance yang lebih besar dapat secara signifikan mengurangi waktu komputasi Anda. Untuk daftar instans yang tersedia, ukuran memori, bandwidth, dan detail kinerja lainnya, lihat [Harga Amazon SageMaker AI](https://aws.amazon.com/sagemaker/pricing/).
+ Tambahkan lebih banyak contoh. SageMaker Clarify dapat menggunakan beberapa instance untuk menjelaskan beberapa titik data input secara paralel. Untuk mengaktifkan komputasi paralel, atur `instance_count` ke lebih dari `1` saat Anda menelepon`SageMakerClarifyProcessor`. Untuk informasi selengkapnya, lihat [Cara menjalankan pekerjaan pemrosesan SageMaker Clarify paralel](clarify-processing-job-run.md#clarify-processing-job-run-spark). Jika Anda meningkatkan jumlah instans, pantau kinerja titik akhir Anda untuk memastikan bahwa instans dapat menerapkan peningkatan beban. Untuk informasi selengkapnya, lihat [Menangkap data dari titik akhir waktu nyata](model-monitor-data-capture-endpoint.md).
+ Jika Anda menghitung SHapley Additive exPlanations (SHAP) nilai, kurangi `num_samples` parameter dalam file konfigurasi analisis Anda. Jumlah sampel secara langsung mempengaruhi hal-hal berikut:
+ Ukuran kumpulan data sintetis yang dikirim ke titik akhir Anda
+ Waktu aktif tugas
Mengurangi jumlah sampel juga dapat menyebabkan berkurangnya akurasi dalam memperkirakan SHAP nilai. Untuk informasi selengkapnya, lihat [File Konfigurasi Analisis](clarify-processing-job-configure-analysis.md).
## Memproses pekerjaan selesai tanpa hasil dan Anda mendapatkan pesan CloudWatch peringatan
Jika pekerjaan pemrosesan selesai tetapi tidak ada hasil yang ditemukan, CloudWatch log menghasilkan pesan peringatan yang mengatakan Signal 15 diterima, dibersihkan. Peringatan ini menunjukkan bahwa pekerjaan dihentikan baik karena permintaan pelanggan disebut `StopProcessingJob` API, atau bahwa pekerjaan kehabisan waktu yang ditentukan untuk penyelesaiannya. Dalam kasus terakhir, periksa runtime maksimum dalam konfigurasi pekerjaan (`max_runtime_in_seconds`) dan tingkatkan sesuai kebutuhan.
## Pesan galat untuk konfigurasi analisis yang tidak valid
+ Jika Anda mendapatkan pesan kesalahan Tidak dapat memuat konfigurasi analisis sebagai JSON. , ini berarti bahwa file input konfigurasi analisis untuk pekerjaan pemrosesan tidak berisi objek JSON yang valid. Periksa validitas objek JSON menggunakan linter JSON.
+ Jika Anda mendapatkan pesan kesalahan Kesalahan validasi skema konfigurasi analisis. , ini berarti bahwa file input konfigurasi analisis untuk pekerjaan pemrosesan berisi bidang yang tidak dikenal atau tipe yang tidak valid untuk beberapa nilai bidang. Tinjau parameter konfigurasi dalam file dan periksa silang dengan parameter yang tercantum dalam file konfigurasi analisis. Untuk informasi selengkapnya, lihat [File Konfigurasi Analisis](clarify-processing-job-configure-analysis.md).
## Perhitungan metrik bias gagal untuk beberapa atau semua metrik
Jika Anda menerima salah satu pesan galat berikut Tidak ada nilai Label yang ada di Kolom Label yang diprediksi, Seri Indeks Prediksi Positif berisi semua nilai Salah. atau Tipe data seri Kolom Label yang Diprediksi tidak sama dengan seri Kolom Label. , coba yang berikut ini:
+ Periksa apakah dataset yang benar sedang digunakan.
+ Periksa apakah ukuran dataset terlalu kecil; apakah, misalnya, hanya berisi beberapa baris. Hal ini dapat menyebabkan output model memiliki nilai yang sama atau tipe data disimpulkan secara tidak benar.
+ Periksa apakah label atau faset diperlakukan sebagai kontinu atau kategoris. SageMaker Clarify menggunakan heuristik untuk menentukan. [https://github.com/aws/amazon-sagemaker-clarify/blob/master/src/smclarify/bias/metrics/common.py#L114)](https://github.com/aws/amazon-sagemaker-clarify/blob/master/src/smclarify/bias/metrics/common.py#L114)) Untuk metrik bias pasca-pelatihan, tipe data yang dikembalikan oleh model mungkin tidak cocok dengan apa yang ada dalam kumpulan data atau SageMaker Clarify mungkin tidak dapat mengubahnya dengan benar.
+ Dalam laporan bias, Anda akan melihat satu nilai untuk kolom kategoris atau interval untuk kolom kontinu.
+ Misalnya, jika kolom memiliki nilai 0.0 dan 1.0 sebagai float, itu akan diperlakukan sebagai kontinu bahkan jika ada terlalu sedikit nilai unik.
## Ketidakcocokan antara konfigurasi analisis dan input/output dataset/model
+ Periksa apakah format dasar dalam konfigurasi analisis sama dengan format kumpulan data.
+ Jika Anda menerima pesan kesalahan Tidak dapat mengonversi string menjadi float. , periksa apakah formatnya ditentukan dengan benar. Ini juga dapat menunjukkan bahwa prediksi model memiliki format yang berbeda dari kolom label atau dapat menunjukkan bahwa konfigurasi untuk label atau probabilitas salah.
+ Jika Anda menerima pesan kesalahan Tidak dapat menemukan facet. atau Header harus berisi label. atau Header dalam konfigurasi tidak cocok dengan jumlah kolom dalam kumpulan data. atau Nama fitur tidak ditemukan. , periksa apakah header cocok dengan kolom.
+ Jika Anda menerima pesan kesalahan Data harus berisi fitur. , periksa template konten untuk JSON Lines dan bandingkan dengan sampel dataset jika tersedia.
## Model mengembalikan 500 Kesalahan Server Internal atau kontainer kembali ke prediksi per rekaman karena kesalahan model
Jika Anda menerima pesan kesalahan Fallback ke prediksi per rekaman karena kesalahan model. , ini dapat menunjukkan bahwa model tidak dapat menangani ukuran batch, atau dibatasi, atau hanya tidak menerima input yang dilewatkan oleh wadah karena masalah serialisasi. Anda harus meninjau CloudWatch log untuk titik akhir SageMaker AI dan mencari pesan kesalahan atau traceback. Untuk kasus pelambatan model, mungkin membantu untuk menggunakan jenis instance yang berbeda atau meningkatkan jumlah instance untuk titik akhir.
## Peran eksekusi tidak valid
Ini menunjukkan bahwa peran yang diberikan salah atau tidak ada izin yang diperlukan. Periksa peran dan izinnya yang digunakan untuk mengonfigurasi pekerjaan pemrosesan dan verifikasi kebijakan izin dan kepercayaan untuk peran tersebut.
## Gagal mengunduh data
Ini menunjukkan bahwa input pekerjaan tidak dapat diunduh untuk memulai pekerjaan. Periksa nama bucket dan izin untuk dataset dan input konfigurasi.
## Tidak dapat terhubung ke SageMaker AI
Ini menunjukkan bahwa pekerjaan tersebut tidak dapat mencapai titik akhir layanan SageMaker AI. Periksa pengaturan konfigurasi jaringan untuk pekerjaan pemrosesan dan verifikasi konfigurasi virtual private cloud (VPC).
## Contoh notebook
Bagian berikut berisi buku catatan untuk membantu Anda mulai menggunakan SageMaker Clarify, menggunakannya untuk tugas-tugas khusus, termasuk yang ada di dalam pekerjaan terdistribusi, dan untuk visi komputer.
### Memulai
Contoh buku catatan berikut menunjukkan cara menggunakan SageMaker Clarify untuk memulai tugas penjelasan dan bias model. Tugas-tugas ini termasuk membuat pekerjaan pemrosesan, melatih model pembelajaran mesin (ML), dan memantau prediksi model:
+ [Penjelasan dan deteksi bias dengan Amazon SageMaker Clarify](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-clarify/fairness_and_explainability/fairness_and_explainability.html) — Gunakan SageMaker Clarify untuk membuat pekerjaan pemrosesan guna mendeteksi bias dan menjelaskan prediksi model.
+ [Memantau penyimpangan bias dan penyimpangan atribusi fitur Amazon SageMaker ](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker_model_monitor/fairness_and_explainability/SageMaker-Model-Monitor-Fairness-and-Explainability.html) Clarify — Gunakan Monitor Model SageMaker Amazon untuk memantau penyimpangan bias dan fitur penyimpangan atribusi dari waktu ke waktu.
+ Cara [membaca kumpulan data dalam format JSON Lines menjadi pekerjaan](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-clarify/fairness_and_explainability/fairness_and_explainability_jsonlines_format.html) pemrosesan SageMaker Clarify.
+ [Mitigasi Bias, latih model lain yang tidak bias, dan masukkan ke dalam registri model](https://github.com/aws/amazon-sagemaker-examples/blob/master/end_to_end/fraud_detection/3-mitigate-bias-train-model2-registry-e2e.ipynb) — Gunakan [Teknik Pengambilan Sampel Minoritas Sintetis (SMOTE) dan SageMaker Klarifikasi untuk mengurangi bias, melatih model lain, lalu](https://arxiv.org/pdf/1106.1813.pdf) memasukkan model baru ke dalam registri model. Notebook contoh ini juga menunjukkan cara menempatkan artefak model baru, termasuk data, kode, dan metadata model, ke dalam registri model. Notebook ini adalah bagian dari seri yang menunjukkan cara mengintegrasikan SageMaker Clarify ke dalam pipeline SageMaker AI yang dijelaskan dalam [Arsitek dan membangun siklus hidup pembelajaran mesin lengkap dengan AWS](https://aws.amazon.com/blogs/machine-learning/architect-and-build-the-full-machine-learning-lifecycle-with-amazon-sagemaker/) posting blog.
### Kasus khusus
Buku catatan berikut menunjukkan cara menggunakan SageMaker Clarify untuk kasus khusus termasuk di dalam wadah Anda sendiri dan untuk tugas pemrosesan bahasa alami:
+ [Keadilan dan Keterjelasan dengan SageMaker Clarify (Bring Your Own Container)](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-clarify/fairness_and_explainability/fairness_and_explainability_byoc.ipynb) — Bangun model dan wadah Anda sendiri yang dapat diintegrasikan dengan SageMaker Clarify untuk mengukur bias dan menghasilkan laporan analisis penjelasan. Notebook contoh ini juga memperkenalkan istilah-istilah utama dan menunjukkan cara mengakses laporan melalui SageMaker Studio Classic.
+ [Keadilan dan Keterjelasan dengan SageMaker Clarify Spark Distributed Processing](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-clarify/fairness_and_explainability/fairness_and_explainability_spark.ipynb) — Gunakan pemrosesan terdistribusi untuk menjalankan pekerjaan SageMaker Clarify yang mengukur bias pra-pelatihan dari kumpulan data dan bias pasca-pelatihan suatu model. Contoh buku catatan ini juga menunjukkan kepada Anda cara mendapatkan penjelasan tentang pentingnya fitur input pada keluaran model, dan mengakses laporan analisis eksplainabilitas melalui SageMaker Studio Classic.
+ [Keterjelasan dengan SageMaker Clarify - Plot Ketergantungan Sebagian (PDP)](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-clarify/fairness_and_explainability/explainability_with_pdp.html) - Gunakan SageMaker Clarify untuk menghasilkan PDPs dan mengakses laporan penjelasan model.
+ [Menjelaskan analisis sentimen teks menggunakan penjelasan SageMaker Clarify Natural language processing (NLP) — Gunakan SageMaker Clarify untuk analisis sentimen teks](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-clarify/text_explainability/text_explainability.html).
+ Gunakan penjelasan visi komputer (CV) untuk [klasifikasi gambar dan deteksi](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-clarify/computer_vision/image_classification/explainability_image_classification.html) [objek](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-clarify/computer_vision/object_detection/object_detection_clarify.html).
Notebook ini telah diverifikasi untuk berjalan di Amazon SageMaker Studio Classic. Jika Anda memerlukan petunjuk tentang cara membuka notebook di Studio Classic, lihat[Membuat atau Membuka Notebook Amazon SageMaker Studio Classic](notebooks-create-open.md). Jika Anda diminta untuk memilih kernel, pilih **Python 3 (Ilmu Data)**.
# Bias Data Pra-pelatihan
Bias algoritmik, diskriminasi, keadilan, dan topik terkait telah dipelajari lintas disiplin ilmu seperti hukum, kebijakan, dan ilmu komputer. Sistem komputer dapat dianggap bias jika mendiskriminasi individu atau kelompok individu tertentu. Model pembelajaran mesin yang mendukung aplikasi ini belajar dari data dan data ini dapat mencerminkan disparitas atau bias inheren lainnya. Misalnya, data pelatihan mungkin tidak memiliki representasi yang cukup dari berbagai kelompok demografis atau mungkin berisi label bias. Model pembelajaran mesin yang dilatih pada kumpulan data yang menunjukkan bias ini akhirnya dapat mempelajarinya dan kemudian mereproduksi atau bahkan memperburuk bias tersebut dalam prediksi mereka. Bidang pembelajaran mesin memberikan kesempatan untuk mengatasi bias dengan mendeteksi dan mengukurnya pada setiap tahap siklus hidup ML. Anda dapat menggunakan Amazon SageMaker Clarify untuk menentukan apakah data yang digunakan untuk model pelatihan mengkodekan bias apa pun
Bias dapat diukur sebelum pelatihan dan setelah pelatihan, dan dipantau terhadap garis dasar setelah menerapkan model ke titik akhir untuk inferensi. Metrik bias pra-pelatihan dirancang untuk mendeteksi dan mengukur bias dalam data mentah sebelum digunakan untuk melatih model. Metrik yang digunakan adalah model-agnostik karena tidak bergantung pada keluaran model apa pun. Namun, ada konsep keadilan yang berbeda yang membutuhkan ukuran bias yang berbeda. Amazon SageMaker Clarify menyediakan metrik bias untuk mengukur berbagai kriteria keadilan.
Untuk informasi tambahan tentang metrik bias, lihat [Pelajari Cara Amazon SageMaker Clarify Membantu Mendeteksi Pengukuran Bias](https://aws.amazon.com/blogs/machine-learning/learn-how-amazon-sagemaker-clarify-helps-detect-bias) [dan Keadilan untuk Machine Learning in Finance](https://pages.awscloud.com/rs/112-TZM-766/images/Fairness.Measures.for.Machine.Learning.in.Finance.pdf).
## Amazon SageMaker Klarifikasi Persyaratan untuk Bias dan Keadilan
SageMaker Clarify menggunakan terminologi berikut untuk membahas bias dan keadilan.
**Fitur**
Properti terukur individu atau karakteristik dari fenomena yang diamati, terkandung dalam kolom untuk data tabular.
**Label**
Fitur yang menjadi target untuk melatih model pembelajaran mesin. Disebut sebagai *label yang diamati* atau *hasil yang diamati*.
**Label yang diprediksi**
Label seperti yang diprediksi oleh model. Juga disebut sebagai *hasil yang diprediksi*.
**Sampel**
Entitas yang diamati dijelaskan oleh nilai fitur dan nilai label, yang terkandung dalam baris untuk data tabel.
**Set data**
Koleksi sampel.
**Bias**
Ketidakseimbangan dalam data pelatihan atau perilaku prediksi model di berbagai kelompok, seperti usia atau kelompok pendapatan. Bias dapat dihasilkan dari data atau algoritma yang digunakan untuk melatih model Anda. Misalnya, jika model ML dilatih terutama pada data dari individu paruh baya, mungkin kurang akurat ketika membuat prediksi yang melibatkan orang yang lebih muda dan lebih tua.
**Metrik bias**
Fungsi yang mengembalikan nilai numerik yang menunjukkan tingkat bias potensial.
**Laporan bias**
Kumpulan metrik bias untuk kumpulan data tertentu, atau kombinasi kumpulan data dan model.
**Nilai label positif**
Nilai label yang menguntungkan kelompok demografis yang diamati dalam sampel. Dengan kata lain, menunjuk sampel sebagai memiliki *hasil positif*.
**Nilai label negatif**
Nilai label yang tidak menguntungkan bagi kelompok demografis yang diamati dalam sampel. Dengan kata lain, menunjuk sampel sebagai memiliki *hasil negatif*.
**Variabel grup**
Kolom kategoris dari kumpulan data yang digunakan untuk membentuk subkelompok untuk pengukuran Disparitas Demografis Bersyarat (CDD). Diperlukan hanya untuk metrik ini sehubungan dengan paradoks Simpson.
**Faset**
Kolom atau fitur yang berisi atribut sehubungan dengan bias yang diukur.
**Nilai segi**
Nilai fitur atribut yang mungkin disukai atau tidak disukai oleh bias.
**Probabilitas yang diprediksi**
Probabilitas, seperti yang diprediksi oleh model, dari sampel yang memiliki hasil positif atau negatif.
## Contoh Notebook
Amazon SageMaker Clarify menyediakan contoh notebook berikut untuk deteksi bias:
+ [Penjelasan dan deteksi bias dengan Amazon SageMaker Clarify](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-clarify/fairness_and_explainability/fairness_and_explainability.html) — Gunakan SageMaker Clarify untuk membuat pekerjaan pemrosesan untuk mendeteksi bias dan menjelaskan prediksi model dengan atribusi fitur.
Notebook ini telah diverifikasi untuk berjalan di Amazon SageMaker Studio saja. Jika Anda memerlukan petunjuk tentang cara membuka buku catatan di Amazon SageMaker Studio, lihat[Membuat atau Membuka Notebook Amazon SageMaker Studio Classic](notebooks-create-open.md). Jika Anda diminta untuk memilih kernel, pilih **Python 3 (Ilmu Data)**.
**Topics**
+ [Amazon SageMaker Klarifikasi Persyaratan untuk Bias dan Keadilan](#clarify-bias-and-fairness-terms)
+ [Contoh Notebook](#clarify-data-bias-sample-notebooks)
+ [Metrik Bias Pra-pelatihan](clarify-measure-data-bias.md)
+ [Hasilkan Laporan untuk Bias dalam Data Pra-pelatihan di Studio SageMaker](clarify-data-bias-reports-ui.md)
# Metrik Bias Pra-pelatihan
Mengukur bias dalam model ML adalah langkah pertama untuk mengurangi bias. Setiap ukuran bias sesuai dengan gagasan keadilan yang berbeda. Bahkan mempertimbangkan konsep keadilan yang sederhana mengarah pada banyak ukuran berbeda yang berlaku dalam berbagai konteks. *Misalnya, pertimbangkan keadilan sehubungan dengan usia, dan, untuk kesederhanaan, bahwa paruh baya dan kelompok usia lainnya adalah dua demografi yang relevan, yang disebut sebagai aspek.* Dalam kasus model ML untuk pinjaman, kita mungkin ingin pinjaman usaha kecil dikeluarkan dengan jumlah yang sama dari kedua demografi. Atau, saat memproses pelamar kerja, kami mungkin ingin melihat jumlah anggota yang sama dari setiap demografis yang dipekerjakan. Namun, pendekatan ini mungkin mengasumsikan bahwa jumlah yang sama dari kedua kelompok umur berlaku untuk pekerjaan ini, jadi kami mungkin ingin mengkondisikan nomor yang berlaku. Lebih lanjut, kami mungkin ingin mempertimbangkan bukan apakah angka yang sama berlaku, tetapi apakah kami memiliki jumlah pelamar yang memenuhi syarat yang sama. Atau, kami dapat menganggap keadilan sebagai tingkat penerimaan yang sama dari pelamar yang memenuhi syarat di kedua demografi usia, atau, tingkat penolakan pelamar yang sama, atau keduanya. Anda dapat menggunakan kumpulan data dengan proporsi data yang berbeda pada atribut yang diinginkan. Ketidakseimbangan ini dapat menggabungkan ukuran bias yang Anda pilih. Model mungkin lebih akurat dalam mengklasifikasikan satu aspek daripada yang lain. Dengan demikian, Anda perlu memilih metrik bias yang secara konseptual sesuai untuk aplikasi dan situasi.
Kami menggunakan notasi berikut untuk membahas metrik bias. Model konseptual yang dijelaskan di sini adalah untuk klasifikasi biner, di mana peristiwa diberi label hanya memiliki dua kemungkinan hasil dalam ruang sampelnya, disebut sebagai positif (dengan nilai 1) dan negatif (dengan nilai 0). Kerangka kerja ini biasanya dapat diperluas ke klasifikasi multikategori secara langsung atau untuk kasus-kasus yang melibatkan hasil bernilai berkelanjutan bila diperlukan. *Dalam kasus klasifikasi biner, label positif dan negatif ditetapkan ke hasil yang dicatat dalam kumpulan data mentah untuk aspek yang disukai *a dan untuk aspek yang* tidak disukai d.* Label y ini disebut sebagai *label yang diamati* untuk membedakannya dari *label yang diprediksi* y' yang ditetapkan oleh model pembelajaran mesin selama tahap pelatihan atau kesimpulan dari siklus hidup ML. Label ini digunakan untuk menentukan distribusi probabilitas P a (y) dan P d (y) untuk hasil faset masing-masing.
+ label:
+ y mewakili n label yang diamati untuk hasil peristiwa dalam kumpulan data pelatihan.
+ y' mewakili label yang diprediksi untuk n label yang diamati dalam kumpulan data oleh model terlatih.
+ hasil:
+ Hasil positif (dengan nilai 1) untuk sampel, seperti penerimaan aplikasi.
+ n (1) adalah jumlah label yang diamati untuk hasil positif (penerimaan).
+ n' (1) adalah jumlah label yang diprediksi untuk hasil positif (penerimaan).
+ Hasil negatif (dengan nilai 0) untuk sampel, seperti penolakan aplikasi.
+ n (0) adalah jumlah label yang diamati untuk hasil negatif (penolakan).
+ n' (0) adalah jumlah label yang diprediksi untuk hasil negatif (penolakan).
+ nilai faset:
+ facet *a* - Nilai fitur yang mendefinisikan demografis yang disukai bias.
+ *n a adalah jumlah label yang diamati untuk nilai faset yang disukai: n a = n a (1) \$1 n a (0) jumlah label yang diamati positif dan negatif untuk aspek nilai a.*
+ *n' a adalah jumlah label yang diprediksi untuk nilai faset yang disukai: n' a = n' a (1) \$1 n' a (0) jumlah label hasil prediksi positif dan negatif untuk nilai faset a.* Perhatikan bahwa n' a = na.
+ facet *d* — Nilai fitur yang mendefinisikan demografis yang bias tidak disukai.
+ *n d adalah jumlah label yang diamati untuk nilai faset yang tidak disukai: n d = n d (1) \$1 n d (0) jumlah label yang diamati positif dan negatif untuk nilai faset d.*
+ *n' d adalah jumlah label yang diprediksi untuk nilai faset yang tidak disukai: n' d = n' d (1) \$1 n' d (0) jumlah label prediksi positif dan negatif untuk nilai faset d.* Perhatikan bahwa n' d = nd.
+ distribusi probabilitas untuk hasil dari hasil data facet berlabel:
+ P a (y) adalah distribusi probabilitas dari label yang diamati untuk faset *a*. Untuk data berlabel biner, distribusi ini diberikan oleh rasio jumlah sampel dalam faset *a* berlabel dengan hasil positif terhadap jumlah total, P a (y 1) = n a (1)/na, dan rasio jumlah sampel dengan hasil negatif terhadap jumlah total, P a (y 0) = n a (0)/n. a
+ P d (y) adalah distribusi probabilitas dari label yang diamati untuk faset *d*. Untuk data berlabel biner, distribusi ini diberikan oleh jumlah sampel dalam segi *d* berlabel hasil positif terhadap jumlah total, P d (y 1) = n d (1)/nd, dan rasio jumlah sampel dengan hasil negatif terhadap jumlah total, P d (y 0) = n d (0)/n. d
Model yang dilatih pada data yang bias oleh kesenjangan demografis mungkin belajar dan bahkan memperburuknya. Untuk mengidentifikasi bias dalam data sebelum mengeluarkan sumber daya untuk melatih model di dalamnya, SageMaker Clarify menyediakan metrik bias data yang dapat Anda hitung pada kumpulan data mentah sebelum pelatihan. Semua metrik pra-pelatihan adalah model-agnostik karena tidak bergantung pada output model dan valid untuk model apa pun. Metrik bias pertama memeriksa ketidakseimbangan aspek, tetapi bukan hasil. Ini menentukan sejauh mana jumlah data pelatihan representatif di berbagai aspek, seperti yang diinginkan untuk aplikasi. Metrik bias yang tersisa membandingkan distribusi label hasil dengan berbagai cara untuk aspek *a* dan *d* dalam data. Metrik yang berkisar di atas nilai negatif dapat mendeteksi bias negatif. Tabel berikut berisi lembar contekan untuk panduan cepat dan tautan ke metrik bias pra-pelatihan.
Metrik Bias Pra-pelatihan
| Metrik bias | Deskripsi | Contoh pertanyaan | Menafsirkan nilai metrik |
| --- | --- | --- | --- |
| [Ketidakseimbangan Kelas (CI)](clarify-bias-metric-class-imbalance.md) | Mengukur ketidakseimbangan jumlah anggota antara nilai faset yang berbeda. | Mungkinkah ada bias berbasis usia karena tidak memiliki cukup data untuk demografis di luar aspek paruh baya? | Rentang dinormalisasi: [-1, \$11] Interpretasi: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/clarify-measure-data-bias.html) |
| [Perbedaan Proporsi Label (DPL)](clarify-data-bias-metric-true-label-imbalance.md) | Mengukur ketidakseimbangan hasil positif antara nilai segi yang berbeda. | Mungkinkah ada bias berbasis usia dalam prediksi MLkarena pelabelan bias nilai faset dalam data? | Rentang untuk label aspek biner & multikategori yang dinormalisasi: [-1, \$11] Rentang untuk label kontinu: (-∞, \$1∞) Interpretasi: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/clarify-measure-data-bias.html) |
| [Divergensi Kullback-Leibler (KL)](clarify-data-bias-metric-kl-divergence.md) | Mengukur seberapa besar distribusi hasil dari berbagai aspek berbeda berbeda satu sama lain secara entropis. | Seberapa berbeda distribusi untuk hasil aplikasi pinjaman untuk kelompok demografis yang berbeda? | Rentang untuk biner, multikategori, kontinu: [0, \$1∞) Interpretasi: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/clarify-measure-data-bias.html) |
| [Divergensi Jensen-Shannon (JS)](clarify-data-bias-metric-jensen-shannon-divergence.md) | Mengukur seberapa besar distribusi hasil dari berbagai aspek berbeda berbeda satu sama lain secara entropis. | Seberapa berbeda distribusi untuk hasil aplikasi pinjaman untuk kelompok demografis yang berbeda? | Rentang untuk biner, multikategori, kontinu: [0, \$1∞) Interpretasi: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/clarify-measure-data-bias.html) |
| [L p -norma (LP)](clarify-data-bias-metric-lp-norm.md) | Mengukur perbedaan p-norma antara distribusi demografis yang berbeda dari hasil yang terkait dengan aspek yang berbeda dalam kumpulan data. | Seberapa berbeda distribusi untuk hasil aplikasi pinjaman untuk demografi yang berbeda? | Rentang untuk biner, multikategori, kontinu: [0, \$1∞) Interpretasi: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/clarify-measure-data-bias.html) |
| [Jarak Variasi Total (TVD)](clarify-data-bias-metric-total-variation-distance.md) | Mengukur setengah dari perbedaan 1 norma L antara distribusi demografis yang berbeda dari hasil yang terkait dengan aspek yang berbeda dalam kumpulan data. | Seberapa berbeda distribusi untuk hasil aplikasi pinjaman untuk demografi yang berbeda? | Rentang untuk hasil biner, multikategori, dan berkelanjutan: [0, \$1∞) [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/clarify-measure-data-bias.html) |
| [Kolmogorov-Smirnov (KS)](clarify-data-bias-metric-kolmogorov-smirnov.md) | Mengukur divergensi maksimum antara hasil dalam distribusi untuk berbagai aspek dalam kumpulan data. | Hasil aplikasi perguruan tinggi mana yang menunjukkan perbedaan terbesar menurut kelompok demografis? | Rentang nilai KS untuk hasil biner, multikategori, dan kontinu: [0, \$11][\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/clarify-measure-data-bias.html) |
| [Disparitas Demografis Bersyarat (CDD)](clarify-data-bias-metric-cddl.md) | Mengukur perbedaan hasil antara aspek yang berbeda secara keseluruhan, tetapi juga oleh subkelompok. | Apakah beberapa kelompok memiliki proporsi penolakan yang lebih besar untuk hasil penerimaan perguruan tinggi daripada proporsi penerimaan mereka? | Rentang CDD: [-1, \$11] [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/clarify-measure-data-bias.html) |
Untuk informasi tambahan tentang metrik bias, lihat [Fairness Measures for Machine Learning in Finance](https://pages.awscloud.com/rs/112-TZM-766/images/Fairness.Measures.for.Machine.Learning.in.Finance.pdf).
**Topics**
+ [Ketidakseimbangan Kelas (CI)](clarify-bias-metric-class-imbalance.md)
+ [Perbedaan Proporsi Label (DPL)](clarify-data-bias-metric-true-label-imbalance.md)
+ [Divergensi Kullback-Leibler (KL)](clarify-data-bias-metric-kl-divergence.md)
+ [Divergensi Jensen-Shannon (JS)](clarify-data-bias-metric-jensen-shannon-divergence.md)
+ [L p -norma (LP)](clarify-data-bias-metric-lp-norm.md)
+ [Jarak Variasi Total (TVD)](clarify-data-bias-metric-total-variation-distance.md)
+ [Kolmogorov-Smirnov (KS)](clarify-data-bias-metric-kolmogorov-smirnov.md)
+ [Disparitas Demografis Bersyarat (CDD)](clarify-data-bias-metric-cddl.md)
# Ketidakseimbangan Kelas (CI)
Bias ketidakseimbangan kelas (CI) terjadi ketika nilai faset *d* memiliki lebih sedikit sampel pelatihan jika dibandingkan dengan aspek lain *a* dalam kumpulan data. *Ini karena model secara istimewa sesuai dengan aspek yang lebih besar dengan mengorbankan aspek yang lebih kecil sehingga dapat menghasilkan kesalahan pelatihan yang lebih tinggi untuk aspek d.* *Model juga berisiko lebih tinggi untuk menyesuaikan set data yang lebih kecil, yang dapat menyebabkan kesalahan pengujian yang lebih besar untuk segi d.* Pertimbangkan contoh di mana model pembelajaran mesin dilatih terutama pada data dari individu paruh baya (aspek a), mungkin kurang akurat ketika membuat prediksi yang melibatkan orang yang lebih muda dan lebih tua (aspek d).
Rumus untuk ukuran ketidakseimbangan segi (dinormalisasi):
CI = (n a - nd)/(n a \$1 nd)
*Dimana n a adalah jumlah anggota faset *a* dan n d bilangan untuk faset d.* Nilainya berkisar pada interval [-1, 1].
+ *Nilai CI positif menunjukkan aspek *A* memiliki lebih banyak sampel pelatihan dalam kumpulan data dan nilai 1 menunjukkan data hanya berisi anggota faset a.*
+ Nilai CI mendekati nol menunjukkan distribusi anggota yang lebih merata antara faset dan nilai nol menunjukkan partisi yang sama sempurna antara faset dan mewakili distribusi sampel yang seimbang dalam data pelatihan.
+ *Nilai CI negatif menunjukkan aspek *d* memiliki lebih banyak sampel pelatihan dalam kumpulan data dan nilai -1 menunjukkan data hanya berisi anggota faset d.*
+ Nilai CI di dekat salah satu nilai ekstrem -1 atau 1 sangat tidak seimbang dan berisiko besar membuat prediksi bias.
Jika ketidakseimbangan aspek yang signifikan ditemukan ada di antara aspek-aspek tersebut, Anda mungkin ingin menyeimbangkan kembali sampel sebelum melanjutkan untuk melatih model di atasnya.
# Perbedaan Proporsi Label (DPL)
Perbedaan proporsi label (DPL) membandingkan proporsi hasil yang diamati dengan label positif untuk segi *D* dengan proporsi hasil yang diamati dengan label positif dari segi *a* dalam kumpulan data pelatihan. Misalnya, Anda dapat menggunakannya untuk membandingkan proporsi individu paruh baya (aspek *a*) dan kelompok usia lainnya (aspek *d*) yang disetujui untuk pinjaman keuangan. Model pembelajaran mesin mencoba meniru keputusan data pelatihan sedekat mungkin. Jadi model pembelajaran mesin yang dilatih pada dataset dengan DPL tinggi kemungkinan akan mencerminkan ketidakseimbangan yang sama dalam prediksi masa depannya.
Rumus untuk perbedaan proporsi label adalah sebagai berikut:
DPL = (q a - q) d
Di mana:
+ q a = n a (1) /n a adalah proporsi faset *a* yang memiliki nilai label yang diamati 1. Misalnya, proporsi demografi paruh baya yang disetujui untuk pinjaman. *Di sini n a (1) mewakili jumlah anggota faset *a* yang mendapatkan hasil positif dan n a adalah jumlah anggota faset a.*
+ q d = n d (1) /n d adalah proporsi faset *d* yang memiliki nilai label yang diamati 1. Misalnya, proporsi orang di luar demografi paruh baya yang disetujui untuk pinjaman. *Di sini n d (1) mewakili jumlah anggota faset *d* yang mendapatkan hasil positif dan n d adalah jumlah anggota faset d.*
Jika DPL cukup dekat dengan 0, maka kita katakan bahwa *paritas demografis* telah tercapai.
Untuk label faset biner dan multikategori, nilai DPL berkisar pada interval (-1, 1). Untuk label kontinu, kami menetapkan ambang batas untuk menciutkan label ke biner.
+ *Nilai DPL positif menunjukkan bahwa faset *a* memiliki proporsi hasil positif yang lebih tinggi jika dibandingkan dengan segi d.*
+ Nilai DPL mendekati nol menunjukkan proporsi hasil positif yang lebih sama antara aspek dan nilai nol menunjukkan paritas demografis yang sempurna.
+ *Nilai DPL negatif menunjukkan bahwa facet *d* memiliki proporsi hasil positif yang lebih tinggi jika dibandingkan dengan faset a.*
Apakah DPL berskala tinggi bermasalah atau tidak bervariasi dari satu situasi ke situasi lainnya. Dalam kasus yang bermasalah, DPL berkekuatan tinggi mungkin merupakan sinyal masalah mendasar dalam data. Misalnya, kumpulan data dengan DPL tinggi mungkin mencerminkan bias atau prasangka historis terhadap kelompok demografis berbasis usia yang tidak diinginkan untuk dipelajari oleh model.
# Divergensi Kullback-Leibler (KL)
*Divergensi Kullback-Leibler (KL) mengukur seberapa besar distribusi label yang diamati dari faset *a*, P a (y), menyimpang dari distribusi faset d, P (y).* d Ia juga dikenal sebagai entropi relatif P a (y) sehubungan dengan P d (y) dan mengukur jumlah informasi yang hilang saat berpindah dari P a (y) ke P d (y).
Rumus untuk divergensi Kullback-Leibler adalah sebagai berikut:
KL (P a \$1\$1 Pd) = Σ y P a (y) \$1 log [P a (y) /P d (y)]
Ini adalah ekspektasi perbedaan logaritmik antara probabilitas P a (y) dan P d (y), di mana ekspektasi ditimbang oleh probabilitas P (y). a Ini bukan jarak sebenarnya antara distribusi karena asimetris dan tidak memenuhi ketidaksetaraan segitiga. Implementasinya menggunakan logaritma alami, memberikan KL dalam satuan nats. Menggunakan basis logaritmik yang berbeda memberikan hasil proporsional tetapi dalam satuan yang berbeda. Misalnya, menggunakan basis 2 memberikan KL dalam satuan bit.
Misalnya, asumsikan bahwa sekelompok pemohon pinjaman memiliki tingkat persetujuan 30% (aspek *d*) dan tingkat persetujuan untuk pelamar lain (aspek *a*) adalah 80%. **Rumus Kullback-Leibler memberi Anda divergensi distribusi label faset a dari segi d sebagai berikut:**
KL = 0,8\$1ln (0,8/0,3) \$10,2\$1ln (0,2/0,7) = 0,53
Ada dua istilah dalam rumus di sini karena label adalah biner dalam contoh ini. Ukuran ini dapat diterapkan ke beberapa label selain yang biner. Misalnya, dalam skenario penerimaan perguruan tinggi, asumsikan pelamar dapat diberi salah satu dari tiga label kategori: y i = \$1y0, y1, y2\$1 = \$1ditolak, daftar tunggu, diterima\$1.
Rentang nilai untuk metrik KL untuk hasil biner, multikategori, dan kontinu adalah [0, \$1∞).
+ Nilai mendekati nol berarti hasilnya didistribusikan dengan cara yang sama untuk berbagai aspek.
+ Nilai positif berarti distribusi label menyimpang, semakin positif semakin besar divergensi.
# Divergensi Jensen-Shannon (JS)
Divergensi Jensen-Shannon (JS) mengukur seberapa besar distribusi label dari berbagai aspek berbeda berbeda satu sama lain secara entropis. Ini didasarkan pada divergensi Kullback-Leibler, tetapi simetris.
Rumus untuk divergensi Jensen-Shannon adalah sebagai berikut:
JS = ½ \$1 [KL (P a \$1\$1 P) \$1 KL (P d \$1\$1 P)]
Dimana P = ½ (P a \$1 Pd), distribusi label rata-rata di seluruh aspek *a* dan *d*.
Kisaran nilai JS untuk hasil biner, multikategori, kontinu adalah [0, ln (2)).
+ Nilai mendekati nol berarti label didistribusikan dengan cara yang sama.
+ Nilai positif berarti distribusi label menyimpang, semakin positif semakin besar divergensi.
Metrik ini menunjukkan apakah ada perbedaan besar di salah satu label di seluruh aspek.
# L p -norma (LP)
pL-norma (LP) mengukur jarak p-norma antara distribusi faset dari label yang diamati dalam kumpulan data pelatihan. Metrik ini non-negatif sehingga tidak dapat mendeteksi bias terbalik.
Rumus untuk p norma L adalah sebagai berikut:
L p (Pa, Pd) = (Σ y \$1\$1P a - P d \$1\$1 p) 1/p
Dimana jarak p-norma antara titik x dan y didefinisikan sebagai berikut:
L p (x, y) = (\$1x 1 -y 1 \$1 p \$1 \$1x -y \$1 p \$1... n \$1\$1x 2 -y 2 \$1 p) 1/p n
Norma 2 adalah norma Euclidean. Asumsikan Anda memiliki distribusi hasil dengan tiga kategori, misalnya, y i = \$1y0, y1, y2\$1 = \$1diterima, daftar tunggu, ditolak\$1 dalam skenario multikategori penerimaan perguruan tinggi. *Anda mengambil jumlah kuadrat perbedaan antara jumlah hasil untuk aspek *a* dan d.* Jarak Euclidean yang dihasilkan dihitung sebagai berikut:
L 2 (Pa, Pd) = [(n a (0) - n d (0)) 2 \$1 (n a (1) - n d (1)) 2 \$1 (n a (2) - n d (2)) 2] 1/2
Di mana:
+ n a (i) adalah jumlah hasil kategori ith dalam segi *a*: misalnya n a (0) adalah jumlah faset *a yang* diterima.
+ n d (i) adalah jumlah hasil kategori ith dalam segi *d*: misalnya n d (2) adalah jumlah penolakan faset *d*.
Rentang nilai LP untuk hasil biner, multikategori, dan kontinu adalah [0, √2), di mana:
+ Nilai mendekati nol berarti label didistribusikan dengan cara yang sama.
+ Nilai positif berarti distribusi label menyimpang, semakin positif semakin besar divergensi.
# Jarak Variasi Total (TVD)
Metrik bias data jarak variasi total (TVD) adalah setengah dari norma L1. **TVD adalah perbedaan terbesar yang mungkin antara distribusi probabilitas untuk hasil label dari segi a dan d.** 1Norma L adalah jarak Hamming, metrik yang digunakan membandingkan dua string data biner dengan menentukan jumlah minimum substitusi yang diperlukan untuk mengubah satu string ke string lainnya. Jika string harus menjadi salinan satu sama lain, itu menentukan jumlah kesalahan yang terjadi saat menyalin. *Dalam konteks deteksi bias, TVD mengukur berapa banyak hasil dalam segi *a yang* harus diubah agar sesuai dengan hasil dalam segi d.*
Rumus untuk Jarak variasi Total adalah sebagai berikut:
TVD = ½ \$1 L 1 (Pa, P) d
Misalnya, asumsikan Anda memiliki distribusi hasil dengan tiga kategori, y i = \$1y0, y1, y2\$1 = \$1diterima, daftar tunggu, ditolak\$1, dalam skenario multikategori penerimaan perguruan tinggi. Anda mengambil perbedaan antara jumlah aspek *a* dan *d untuk setiap hasil untuk menghitung TVD*. Hasilnya adalah sebagai berikut:
L 1 (Pa, Pd) = \$1n a (0) - n d (0) \$1 \$1 \$1n a (1) - n d (1) \$1 \$1 \$1n a (2) - n d (2) \$1
Di mana:
+ n a (i) adalah jumlah hasil kategori ith dalam segi *a*: misalnya n a (0) adalah jumlah faset *a yang* diterima.
+ n d (i) adalah jumlah hasil kategori ith dalam segi d: misalnya n d (2) adalah jumlah penolakan faset *d*.
Rentang nilai TVD untuk hasil biner, multikategori, dan kontinu adalah [0, 1), di mana:
+ Nilai mendekati nol berarti label didistribusikan dengan cara yang sama.
+ Nilai positif berarti distribusi label menyimpang, semakin positif semakin besar divergensi.
# Kolmogorov-Smirnov (KS)
**Metrik bias Kolmogorov-Smirnov (KS) sama dengan divergensi maksimum antara label dalam distribusi untuk aspek a dan d dari kumpulan data.** Uji KS dua sampel yang dilaksanakan oleh SageMaker Clarify melengkapi ukuran ketidakseimbangan label lainnya dengan menemukan label yang paling tidak seimbang.
Rumus untuk metrik Kolmogorov-Smirnov adalah sebagai berikut:
KS = maks (\$1P a (y) - P d (y) \$1)
Misalnya, asumsikan sekelompok pelamar (aspek *a*) ke perguruan tinggi ditolak, daftar tunggu, atau diterima masing-masing 40%, 40%, 20% dan bahwa tarif ini untuk pelamar lain (aspek *d*) adalah 20%, 10%, 70%. Maka nilai metrik bias Kolmogorov-Smirnov adalah sebagai berikut:
KS = maks (\$10,4-0,2 \$1, \$10,4-0,1\$1, \$10,2-0,7 \$1) = 0,5
Ini memberi tahu kita perbedaan maksimum antara distribusi faset adalah 0,5 dan terjadi pada tingkat penerimaan. Ada tiga istilah dalam persamaan karena label adalah multikelas kardinalitas tiga.
Rentang nilai LP untuk hasil biner, multikategori, dan kontinu adalah [0, \$11], di mana:
+ Nilai mendekati nol menunjukkan label didistribusikan secara merata antar aspek di semua kategori hasil. Misalnya, kedua aspek yang mengajukan pinjaman mendapat 50% dari penerimaan dan 50% dari penolakan.
+ Nilai di dekat satu menunjukkan label untuk satu hasil semuanya dalam satu segi. *Misalnya, facet *a* mendapat 100% dari penerimaan dan facet d tidak punya.*
+ Nilai intermiten menunjukkan derajat relatif ketidakseimbangan label maksimum.
# Disparitas Demografis Bersyarat (CDD)
Metrik disparitas demografis (DD) menentukan apakah suatu aspek memiliki proporsi yang lebih besar dari hasil yang ditolak dalam kumpulan data daripada hasil yang diterima. *Dalam kasus biner di mana ada dua aspek, pria dan wanita misalnya, yang merupakan kumpulan data, yang tidak disukai diberi label segi *d* dan yang disukai diberi label faset a.* Misalnya, dalam kasus penerimaan perguruan tinggi, jika pelamar perempuan terdiri dari 46% dari pelamar yang ditolak dan hanya terdiri dari 32% dari pelamar yang diterima, kami mengatakan bahwa ada *perbedaan demografis* karena tingkat di mana perempuan ditolak melebihi tingkat di mana mereka diterima. Pelamar perempuan diberi label facet *d* dalam kasus ini. Jika pelamar laki-laki terdiri dari 54% dari pelamar yang ditolak dan 68% dari pelamar yang diterima, maka tidak ada perbedaan demografis untuk aspek ini karena tingkat penolakan kurang dari tingkat penerimaan. Pelamar pria diberi label facet *a* dalam kasus ini.
*Rumus untuk disparitas demografis untuk aspek yang kurang disukai d adalah sebagai berikut:*
DD d = n d (0) /n (0) - n d (1) /n (1) = P d R (y 0) - P d A (y 1)
Di mana:
+ *n (0) = n a (0) \$1 n d (0) adalah jumlah total hasil yang ditolak dalam kumpulan data untuk aspek yang disukai *a dan aspek yang* kurang beruntung d.*
+ *n (1) = n a (1) \$1 n d (1) adalah jumlah total hasil yang diterima dalam kumpulan data untuk aspek yang disukai *a dan aspek yang* kurang beruntung d.*
+ P d R (y 0) adalah proporsi hasil yang ditolak (dengan nilai 0) dalam segi *d*.
+ P d A (y 1) adalah proporsi hasil yang diterima (nilai 1) dalam segi *d*.
Untuk contoh penerimaan perguruan tinggi, perbedaan demografis untuk wanita adalah DD d = 0,46 - 0,32 = 0,14. Untuk pria DD a = 0,54 - 0,68 = - 0,14.
Metrik disparitas demografis bersyarat (CDD) yang mengkondisikan DD pada atribut yang menentukan strata subkelompok pada kumpulan data diperlukan untuk mengesampingkan paradoks Simpson. Pengelompokan kembali dapat memberikan wawasan tentang penyebab kesenjangan demografis yang jelas untuk aspek yang kurang disukai. Kasus klasik muncul dalam kasus penerimaan Berkeley di mana pria diterima pada tingkat yang lebih tinggi secara keseluruhan daripada wanita. Statistik untuk kasus ini digunakan dalam contoh perhitungan DD. Namun, ketika subkelompok departemen diperiksa, wanita terbukti memiliki tingkat penerimaan yang lebih tinggi daripada pria ketika dikondisikan oleh departemen. Penjelasannya adalah bahwa wanita telah mendaftar ke departemen dengan tingkat penerimaan yang lebih rendah daripada pria. Meneliti tingkat penerimaan subkelompok mengungkapkan bahwa wanita sebenarnya diterima pada tingkat yang lebih tinggi daripada pria untuk departemen dengan tingkat penerimaan yang lebih rendah.
Metrik CDD memberikan ukuran tunggal untuk semua perbedaan yang ditemukan dalam subkelompok yang ditentukan oleh atribut kumpulan data dengan meratakannya. Ini didefinisikan sebagai rata-rata tertimbang disparitas demografis (DDi) untuk masing-masing subkelompok, dengan setiap disparitas subkelompok tertimbang secara proporsional dengan jumlah pengamatan yang terkandung. Rumus untuk disparitas demografis bersyarat adalah sebagai berikut:
CDD = (1/n) \$1 Σ i n DD i \$1 i
Di mana:
+ in i = n adalah jumlah total pengamatan dan n i adalah jumlah pengamatan untuk setiap subkelompok.
+ DD i = n i (0) /n (0) - n i (1) /n (1) = P i R (y 0) - P i A (y 1) adalah disparitas demografis untuk subkelompok ith.
Perbedaan demografis untuk subkelompok (DDi) adalah perbedaan antara proporsi hasil yang ditolak dan proporsi hasil yang diterima untuk setiap subkelompok.
Kisaran nilai DD untuk hasil biner untuk kumpulan data lengkap DD d atau untuk subkelompok terkondisionalisasi DD i adalah [-1, \$11].
+ *\$11: ketika tidak ada penolakan dalam segi *a* atau subkelompok dan tidak ada penerimaan di segi d atau subkelompok*
+ Nilai positif menunjukkan ada perbedaan demografis karena aspek *d* atau subkelompok memiliki proporsi yang lebih besar dari hasil yang ditolak dalam kumpulan data daripada hasil yang diterima. Semakin tinggi nilainya, semakin sedikit faset dan semakin besar perbedaannya.
+ Nilai negatif menunjukkan tidak ada perbedaan demografis karena aspek *d* atau subkelompok memiliki proporsi yang lebih besar dari hasil yang diterima dalam kumpulan data daripada hasil yang ditolak. Semakin rendah nilainya, semakin disukai fasetnya.
+ *-1: ketika tidak ada penolakan dalam segi *d* atau subkelompok dan tidak ada penerimaan dalam segi a atau subkelompok*
Jika Anda tidak mengkondisikan apa pun maka CDD adalah nol jika dan hanya jika DPL adalah nol.
Metrik ini berguna untuk mengeksplorasi konsep diskriminasi langsung dan tidak langsung dan pembenaran obyektif dalam hukum dan yurisprudensi non-diskriminasi UE dan Inggris. Untuk informasi tambahan, lihat [Mengapa Keadilan Tidak Dapat Diotomatisasi](https://arxiv.org/abs/2005.05906). Paper ini juga berisi data dan analisis yang relevan dari kasus penerimaan Berkeley yang menunjukkan bagaimana kondisionalisasi pada subkelompok tingkat penerimaan departemen menggambarkan paradoks Simpson.
# Hasilkan Laporan untuk Bias dalam Data Pra-pelatihan di Studio SageMaker
SageMaker Clarify terintegrasi dengan Amazon SageMaker Data Wrangler, yang dapat membantu Anda mengidentifikasi bias selama persiapan data tanpa harus menulis kode Anda sendiri. Data Wrangler menyediakan end-to-end solusi untuk mengimpor, menyiapkan, mengubah, membuat fitur, dan menganalisis data dengan Amazon Studio. SageMaker Untuk ikhtisar alur kerja persiapan data Data Wrangler, lihat. [Siapkan Data ML dengan Amazon SageMaker Data Wrangler](data-wrangler.md)
Anda menentukan atribut yang diminati, seperti jenis kelamin atau usia, dan SageMaker Clarify menjalankan serangkaian algoritme untuk mendeteksi adanya bias pada atribut tersebut. Setelah algoritme berjalan, SageMaker Clarify memberikan laporan visual dengan deskripsi sumber dan tingkat keparahan bias yang mungkin sehingga Anda dapat merencanakan langkah-langkah untuk mengurangi. Misalnya, dalam kumpulan data keuangan yang berisi beberapa contoh pinjaman bisnis untuk satu kelompok umur dibandingkan dengan yang lain, SageMaker AI menandai ketidakseimbangan sehingga Anda dapat menghindari model yang tidak menyukai kelompok usia tersebut.
**Untuk menganalisis dan melaporkan bias data**
Untuk memulai dengan Data Wrangler, lihat. [Memulai dengan Data Wrangler](data-wrangler-getting-started.md)
1. Di Amazon SageMaker Studio Classic, dari menu **Home** (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/studio/icons/house.png)) di panel kiri, navigasikan ke node **Data**, lalu pilih **Data Wrangler**. Ini membuka **halaman landing Data Wrangler** di Studio Classic.
1. Pilih tombol **\$1 Impor data** untuk membuat alur baru.
1. **Di halaman alur, dari tab **Impor**, pilih Amazon S3, arahkan ke bucket Amazon S3, temukan kumpulan data, lalu pilih Impor.**
1. Setelah Anda mengimpor data Anda, pada grafik aliran di tab **Aliran data**, pilih tanda **\$1** di sebelah kanan simpul **Tipe data**.
1. Pilih **Tambahkan analisis**.
1. Pada halaman **Buat Analisis**, pilih **Laporan Bias** untuk **jenis Analisis**.
1. Konfigurasikan laporan bias dengan memberikan **Nama** laporan, kolom untuk memprediksi dan apakah itu nilai atau ambang batas, kolom untuk menganalisis bias (segi) dan apakah itu nilai atau ambang batas.
1. Lanjutkan mengonfigurasi laporan bias dengan memilih metrik bias.
![\[Pilih metrik bias.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/clarify-data-wrangler-configure-bias-metrics.png)
1. Pilih **Periksa bias untuk** menghasilkan dan melihat laporan bias. Gulir ke bawah untuk melihat semua laporan.
![\[Hasilkan dan lihat laporan bias.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/clarify-data-wrangler-create-bias-report.png)
1. Pilih tanda sisipan di sebelah kanan setiap deskripsi metrik bias untuk melihat dokumentasi yang dapat membantu Anda menafsirkan signifikansi nilai metrik.
1. Untuk melihat ringkasan tabel dari nilai metrik bias, pilih sakelar **Tabel**. Untuk menyimpan laporan, pilih **Simpan** di sudut kanan bawah halaman. Anda dapat melihat laporan pada grafik aliran di tab **Aliran data**. Klik dua kali pada laporan untuk membukanya.
# Data Pasca Pelatihan dan Bias Model
Analisis bias pasca-pelatihan dapat membantu mengungkapkan bias yang mungkin berasal dari bias dalam data, atau dari bias yang diperkenalkan oleh algoritma klasifikasi dan prediksi. Analisis ini mempertimbangkan data, termasuk label, dan prediksi model. Anda menilai kinerja dengan menganalisis label yang diprediksi atau dengan membandingkan prediksi dengan nilai target yang diamati dalam data sehubungan dengan kelompok dengan atribut yang berbeda. Ada pengertian keadilan yang berbeda, masing-masing membutuhkan metrik bias yang berbeda untuk diukur.
Ada konsep hukum keadilan yang mungkin tidak mudah ditangkap karena sulit dideteksi. Misalnya, konsep AS tentang dampak berbeda yang terjadi ketika suatu kelompok, yang disebut sebagai aspek yang kurang disukai *d*, mengalami efek buruk bahkan ketika pendekatan yang diambil tampaknya adil. Jenis bias ini mungkin bukan karena model pembelajaran mesin, tetapi mungkin masih dapat dideteksi dengan analisis bias pasca-pelatihan.
Amazon SageMaker Clarify mencoba memastikan penggunaan terminologi yang konsisten. Untuk daftar istilah dan definisinya, lihat[Amazon SageMaker Klarifikasi Persyaratan untuk Bias dan Keadilan](clarify-detect-data-bias.md#clarify-bias-and-fairness-terms).
Untuk informasi tambahan tentang metrik bias pasca-pelatihan, lihat [Pelajari Cara Amazon SageMaker Memperjelas Membantu Mendeteksi Pengukuran Bias](https://aws.amazon.com/blogs/machine-learning/learn-how-amazon-sagemaker-clarify-helps-detect-bias/) [dan Keadilan untuk Machine Learning](https://pages.awscloud.com/rs/112-TZM-766/images/Fairness.Measures.for.Machine.Learning.in.Finance.pdf) in Finance. .
# Data Pasca-pelatihan dan Metrik Bias Model
Amazon SageMaker Clarify menyediakan sebelas data pasca-pelatihan dan metrik bias model untuk membantu mengukur berbagai konsepsi keadilan. Konsep-konsep ini tidak dapat dipenuhi secara bersamaan dan seleksi tergantung pada spesifik kasus yang melibatkan bias potensial yang dianalisis. Sebagian besar metrik ini adalah kombinasi dari angka-angka yang diambil dari matriks kebingungan klasifikasi biner untuk kelompok demografis yang berbeda. Karena keadilan dan bias dapat didefinisikan oleh berbagai metrik, penilaian manusia diperlukan untuk memahami dan memilih metrik mana yang relevan dengan kasus penggunaan individu, dan pelanggan harus berkonsultasi dengan pemangku kepentingan yang tepat untuk menentukan ukuran keadilan yang tepat untuk aplikasi mereka.
Kami menggunakan notasi berikut untuk membahas metrik bias. Model konseptual yang dijelaskan di sini adalah untuk klasifikasi biner, di mana peristiwa diberi label hanya memiliki dua kemungkinan hasil dalam ruang sampelnya, disebut sebagai positif (dengan nilai 1) dan negatif (dengan nilai 0). Kerangka kerja ini biasanya dapat diperluas ke klasifikasi multikategori secara langsung atau untuk kasus-kasus yang melibatkan hasil bernilai berkelanjutan bila diperlukan. *Dalam kasus klasifikasi biner, label positif dan negatif ditetapkan ke hasil yang dicatat dalam kumpulan data mentah untuk aspek yang disukai *a dan untuk aspek yang* tidak disukai d.* Label y ini disebut sebagai *label yang diamati* untuk membedakannya dari *label yang diprediksi* y' yang ditetapkan oleh model pembelajaran mesin selama tahap pelatihan atau kesimpulan dari siklus hidup ML. Label ini digunakan untuk menentukan distribusi probabilitas P a (y) dan P d (y) untuk hasil faset masing-masing.
+ label:
+ y mewakili n label yang diamati untuk hasil peristiwa dalam kumpulan data pelatihan.
+ y' mewakili label yang diprediksi untuk n label yang diamati dalam kumpulan data oleh model terlatih.
+ hasil:
+ Hasil positif (dengan nilai 1) untuk sampel, seperti penerimaan aplikasi.
+ n (1) adalah jumlah label yang diamati untuk hasil positif (penerimaan).
+ n' (1) adalah jumlah label yang diprediksi untuk hasil positif (penerimaan).
+ Hasil negatif (dengan nilai 0) untuk sampel, seperti penolakan aplikasi.
+ n (0) adalah jumlah label yang diamati untuk hasil negatif (penolakan).
+ n' (0) adalah jumlah label yang diprediksi untuk hasil negatif (penolakan).
+ nilai faset:
+ facet *a* - Nilai fitur yang mendefinisikan demografis yang disukai bias.
+ *n a adalah jumlah label yang diamati untuk nilai faset yang disukai: n a = n a (1) \$1 n a (0) jumlah label yang diamati positif dan negatif untuk aspek nilai a.*
+ *n' a adalah jumlah label yang diprediksi untuk nilai faset yang disukai: n' a = n' a (1) \$1 n' a (0) jumlah label hasil prediksi positif dan negatif untuk nilai faset a.* Perhatikan bahwa n' a = na.
+ facet *d* — Nilai fitur yang mendefinisikan demografis yang bias tidak disukai.
+ *n d adalah jumlah label yang diamati untuk nilai faset yang tidak disukai: n d = n d (1) \$1 n d (0) jumlah label yang diamati positif dan negatif untuk nilai faset d.*
+ *n' d adalah jumlah label yang diprediksi untuk nilai faset yang tidak disukai: n' d = n' d (1) \$1 n' d (0) jumlah label prediksi positif dan negatif untuk nilai faset d.* Perhatikan bahwa n' d = nd.
+ distribusi probabilitas untuk hasil dari hasil data facet berlabel:
+ P a (y) adalah distribusi probabilitas dari label yang diamati untuk faset *a*. Untuk data berlabel biner, distribusi ini diberikan oleh rasio jumlah sampel dalam faset *a* berlabel dengan hasil positif terhadap jumlah total, P a (y 1) = n a (1)/na, dan rasio jumlah sampel dengan hasil negatif terhadap jumlah total, P a (y 0) = n a (0)/n. a
+ P d (y) adalah distribusi probabilitas dari label yang diamati untuk faset *d*. Untuk data berlabel biner, distribusi ini diberikan oleh jumlah sampel dalam segi *d* berlabel hasil positif terhadap jumlah total, P d (y 1) = n d (1)/nd, dan rasio jumlah sampel dengan hasil negatif terhadap jumlah total, P d (y 0) = n d (0)/n. d
Tabel berikut berisi lembar contekan untuk panduan cepat dan tautan ke metrik bias pasca-pelatihan.
Metrik bias pasca-pelatihan
| Metrik bias pasca-pelatihan | Deskripsi | Contoh pertanyaan | Menafsirkan nilai metrik |
| --- | --- | --- | --- |
| [Perbedaan Proporsi Positif pada Label Prediksi (DPPL)](clarify-post-training-bias-metric-dppl.md) | Mengukur perbedaan proporsi prediksi positif antara aspek yang disukai a dan aspek yang tidak disukai d. | Apakah ada ketidakseimbangan antar kelompok demografis dalam hasil positif yang diprediksi yang mungkin mengindikasikan bias? | Rentang untuk label aspek biner & multikategori yang dinormalisasi: `[-1,+1]` Rentang untuk label kontinu: (-∞, \$1∞) Interpretasi: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/clarify-measure-post-training-bias.html) |
| [Dampak Berbeda (DI)](clarify-post-training-bias-metric-di.md) | Mengukur rasio proporsi label yang diprediksi untuk aspek yang disukai a dan aspek yang tidak disukai d. | Apakah ada ketidakseimbangan antar kelompok demografis dalam hasil positif yang diprediksi yang mungkin mengindikasikan bias? | Rentang untuk biner dinormalisasi, aspek multikategori, dan label kontinu: [0, ∞) Interpretasi: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/clarify-measure-post-training-bias.html) |
| [Disparitas Demografis Bersyarat dalam Label yang Diprediksi (CDDPL)](clarify-post-training-bias-metric-cddpl.md) | Mengukur perbedaan label yang diprediksi antara aspek secara keseluruhan, tetapi juga oleh subkelompok. | Apakah beberapa kelompok demografis memiliki proporsi penolakan yang lebih besar untuk hasil aplikasi pinjaman daripada proporsi penerimaan mereka? | Kisaran nilai CDDPL untuk hasil biner, multikategori, dan berkelanjutan: `[-1, +1]` [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/clarify-measure-post-training-bias.html) |
| [Fliptest Kontrafaktual (FT)](clarify-post-training-bias-metric-ft.md) | Memeriksa setiap anggota faset d dan menilai apakah anggota yang serupa dari segi a memiliki prediksi model yang berbeda. | Apakah satu kelompok demografi usia tertentu cocok dengan semua fitur dengan kelompok usia yang berbeda, namun dibayar lebih rata-rata? | Rentang untuk label facet biner dan multikategori adalah. [-1, \$11] [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/clarify-measure-post-training-bias.html) |
| [Perbedaan Akurasi (AD)](clarify-post-training-bias-metric-ad.md) | Mengukur perbedaan antara akurasi prediksi untuk aspek yang disukai dan yang tidak disukai. | Apakah model memprediksi label secara akurat untuk aplikasi di semua kelompok demografis? | Rentang untuk label facet biner dan multikategori adalah. [-1, \$11][\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/clarify-measure-post-training-bias.html) |
| [Ingat Perbedaan (RD)](clarify-post-training-bias-metric-rd.md) | Membandingkan penarikan kembali model untuk aspek yang disukai dan tidak disukai. | Apakah ada bias berbasis usia dalam pinjaman karena model yang memiliki daya ingat yang lebih tinggi untuk satu kelompok usia dibandingkan dengan yang lain? | Rentang untuk klasifikasi biner dan multikategori:. `[-1, +1]` [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/clarify-measure-post-training-bias.html) |
| [Perbedaan Penerimaan Bersyarat () DCAcc](clarify-post-training-bias-metric-dcacc.md) | Membandingkan label yang diamati dengan label yang diprediksi oleh model. Menilai apakah ini sama di seluruh aspek untuk hasil positif yang diprediksi (penerimaan). | Ketika membandingkan satu kelompok usia dengan yang lain, apakah pinjaman diterima lebih sering, atau lebih jarang dari yang diperkirakan (berdasarkan kualifikasi)? | Rentang untuk biner, aspek multikategori, dan label kontinu: (-∞, \$1∞). [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/clarify-measure-post-training-bias.html) |
| [Perbedaan Tingkat Penerimaan (DAR)](clarify-post-training-bias-metric-dar.md) | Mengukur perbedaan rasio hasil positif yang diamati (TP) dengan positif yang diprediksi (TP \$1 FP) antara aspek yang disukai dan yang tidak disukai. | Apakah model memiliki presisi yang sama ketika memprediksi penerimaan pinjaman untuk pelamar yang memenuhi syarat di semua kelompok umur? | Rentang untuk biner, aspek multikategori, dan label kontinu adalah. [-1, \$11][\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/clarify-measure-post-training-bias.html) |
| [Perbedaan spesifisitas (SD)](clarify-post-training-bias-metric-sd.md) | Membandingkan kekhususan model antara aspek yang disukai dan yang tidak disukai. | Apakah ada bias berbasis usia dalam pinjaman karena model memprediksi spesifisitas yang lebih tinggi untuk satu kelompok umur dibandingkan dengan yang lain? | Rentang untuk klasifikasi biner dan multikategori:. `[-1, +1]` [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/clarify-measure-post-training-bias.html) |
| [Perbedaan Penolakan Bersyarat (DCR)](clarify-post-training-bias-metric-dcr.md) | Membandingkan label yang diamati dengan label yang diprediksi oleh model dan menilai apakah ini sama di seluruh aspek untuk hasil negatif (penolakan). | Apakah ada lebih banyak atau lebih sedikit penolakan untuk aplikasi pinjaman daripada yang diperkirakan untuk satu kelompok umur dibandingkan dengan yang lain berdasarkan kualifikasi? | Rentang untuk biner, aspek multikategori, dan label kontinu: (-∞, \$1∞).[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/clarify-measure-post-training-bias.html) |
| [Perbedaan Tingkat Penolakan (DRR)](clarify-post-training-bias-metric-drr.md) | Mengukur perbedaan rasio hasil negatif yang diamati (TN) dengan negatif yang diprediksi (TN\$1FN) antara aspek yang tidak disukai dan disukai. | Apakah model memiliki presisi yang sama ketika memprediksi penolakan pinjaman untuk pelamar yang tidak memenuhi syarat di semua kelompok umur? | Rentang untuk biner, aspek multikategori, dan label kontinu adalah. [-1, \$11][\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/clarify-measure-post-training-bias.html) |
| [Kesetaraan Perawatan (TE)](clarify-post-training-bias-metric-te.md) | Mengukur perbedaan rasio positif palsu dengan negatif palsu antara aspek yang disukai dan yang tidak disukai. | Dalam aplikasi pinjaman, apakah rasio relatif positif palsu terhadap negatif palsu sama di semua demografi usia? | Rentang untuk label faset biner dan multikategori: (-∞, \$1∞).[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/clarify-measure-post-training-bias.html) |
| [Entropi umum (GE)](clarify-post-training-bias-metric-ge.md) | Mengukur ketidaksetaraan manfaat yang b diberikan untuk setiap input oleh prediksi model. | Dari dua model kandidat untuk klasifikasi aplikasi pinjaman, apakah yang satu mengarah pada distribusi hasil yang diinginkan yang lebih tidak merata daripada yang lain? | Rentang untuk label biner dan multikategori: (0, 0,5). GE tidak terdefinisi ketika model hanya memprediksi negatif palsu.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/clarify-measure-post-training-bias.html) |
Untuk informasi tambahan tentang metrik bias pasca-pelatihan, lihat [A Family of Fairness Measures for Machine Learning](https://pages.awscloud.com/rs/112-TZM-766/images/Fairness.Measures.for.Machine.Learning.in.Finance.pdf) in Finance.
**Topics**
+ [Perbedaan Proporsi Positif pada Label Prediksi (DPPL)](clarify-post-training-bias-metric-dppl.md)
+ [Dampak Berbeda (DI)](clarify-post-training-bias-metric-di.md)
+ [Perbedaan Penerimaan Bersyarat () DCAcc](clarify-post-training-bias-metric-dcacc.md)
+ [Perbedaan Penolakan Bersyarat (DCR)](clarify-post-training-bias-metric-dcr.md)
+ [Perbedaan spesifisitas (SD)](clarify-post-training-bias-metric-sd.md)
+ [Ingat Perbedaan (RD)](clarify-post-training-bias-metric-rd.md)
+ [Perbedaan Tingkat Penerimaan (DAR)](clarify-post-training-bias-metric-dar.md)
+ [Perbedaan Tingkat Penolakan (DRR)](clarify-post-training-bias-metric-drr.md)
+ [Perbedaan Akurasi (AD)](clarify-post-training-bias-metric-ad.md)
+ [Kesetaraan Perawatan (TE)](clarify-post-training-bias-metric-te.md)
+ [Disparitas Demografis Bersyarat dalam Label yang Diprediksi (CDDPL)](clarify-post-training-bias-metric-cddpl.md)
+ [Fliptest Kontrafaktual (FT)](clarify-post-training-bias-metric-ft.md)
+ [Entropi umum (GE)](clarify-post-training-bias-metric-ge.md)
# Perbedaan Proporsi Positif pada Label Prediksi (DPPL)
Perbedaan proporsi positif dalam metrik label prediksi (DPPL) menentukan apakah model memprediksi hasil secara berbeda untuk setiap aspek. *Ini didefinisikan sebagai perbedaan antara proporsi prediksi positif (y' = 1) untuk segi *a* dan proporsi prediksi positif (y' = 1) untuk segi d.* *Misalnya, jika prediksi model memberikan pinjaman kepada 60% dari kelompok paruh baya (aspek *a*) dan 50% kelompok usia lainnya (segi *d), itu mungkin bias terhadap aspek d*.* Dalam contoh ini, Anda harus menentukan apakah perbedaan 10% material untuk kasus bias.
Perbandingan perbedaan proporsi label (DPL), ukuran bias pra-pelatihan, dengan DPPL, ukuran bias pasca-pelatihan, menilai apakah bias dalam proporsi positif yang awalnya ada dalam dataset berubah setelah pelatihan. Jika DPPL lebih besar dari DPL, maka bias dalam proporsi positif meningkat setelah pelatihan. Jika DPPL lebih kecil dari DPL, model tidak meningkatkan bias dalam proporsi positif setelah pelatihan. Membandingkan DPL terhadap DPPL tidak menjamin bahwa model mengurangi bias di sepanjang semua dimensi. Misalnya, model mungkin masih bias saat mempertimbangkan metrik lain seperti [Fliptest Kontrafaktual (FT)](clarify-post-training-bias-metric-ft.md) atau. [Perbedaan Akurasi (AD)](clarify-post-training-bias-metric-ad.md) Untuk informasi selengkapnya tentang deteksi bias, lihat posting blog [Pelajari cara Amazon SageMaker Clarify membantu mendeteksi bias](https://aws.amazon.com/blogs/machine-learning/learn-how-amazon-sagemaker-clarify-helps-detect-bias/). Lihat [Perbedaan Proporsi Label (DPL)](clarify-data-bias-metric-true-label-imbalance.md) untuk informasi lebih lanjut tentang DPL.
Rumus untuk DPPL adalah:
DPPL = q' - q' a d
Di mana:
+ q' a = n' a (1) /n a adalah proporsi prediksi dari segi *a* yang mendapatkan hasil positif dari nilai 1. Dalam contoh kami, proporsi aspek paruh baya diprediksi akan diberikan pinjaman. *Di sini n' a (1) mewakili jumlah anggota faset *a* yang mendapatkan hasil prediksi positif dari nilai 1 dan n a adalah jumlah anggota faset a.*
+ q' d = n' d (1) /n d adalah proporsi prediksi dari segi *d* yang mendapatkan hasil positif dari nilai 1. Dalam contoh kita, aspek orang tua dan muda diprediksi akan diberikan pinjaman. *Di sini n' d (1) mewakili jumlah anggota faset *d* yang mendapatkan hasil prediksi positif dan n d adalah jumlah anggota segi d.*
Jika DPPL cukup dekat dengan 0, itu berarti *paritas demografis* pasca-pelatihan telah tercapai.
Untuk label faset biner dan multikategori, nilai DPL yang dinormalisasi berkisar pada interval [-1, 1]. Untuk label kontinu, nilainya bervariasi selama interval (-∞, \$1∞).
+ *Nilai DPPL positif menunjukkan bahwa faset *a* memiliki proporsi hasil positif yang diprediksi lebih tinggi jika dibandingkan dengan segi d.*
Ini disebut sebagai *bias positif*.
+ Nilai DPPL mendekati nol menunjukkan proporsi yang lebih sama dari hasil positif yang diprediksi antara aspek *a* dan *d* dan nilai nol menunjukkan paritas demografis yang sempurna.
+ *Nilai DPPL negatif menunjukkan bahwa faset *d* memiliki proporsi hasil positif yang diprediksi lebih tinggi jika dibandingkan dengan faset a.* Ini disebut sebagai *bias negatif*.
# Dampak Berbeda (DI)
Perbedaan proporsi positif dalam metrik label yang diprediksi dapat dinilai dalam bentuk rasio.
Perbandingan proporsi positif dalam metrik label yang diprediksi dapat dinilai dalam bentuk rasio, bukan sebagai perbedaan, seperti halnya dengan. [Perbedaan Proporsi Positif pada Label Prediksi (DPPL)](clarify-post-training-bias-metric-dppl.md) *Metrik dampak berbeda (DI) didefinisikan sebagai rasio proporsi prediksi positif (y' = 1) untuk segi *d* atas proporsi prediksi positif (y' = 1) untuk faset a.* *Misalnya, jika prediksi model memberikan pinjaman kepada 60% dari kelompok paruh baya (segi *a*) dan 50% kelompok usia lainnya (segi *d*), maka DI = .5/.6 = 0,8, yang menunjukkan bias positif dan dampak buruk pada kelompok usia lainnya yang diwakili oleh segi d.*
Rumus untuk rasio proporsi label yang diprediksi:
DI = q' d /q 'a
Di mana:
+ q' a = n' a (1) /n a adalah proporsi prediksi dari segi *a* yang mendapatkan hasil positif dari nilai 1. Dalam contoh kami, proporsi aspek paruh baya diprediksi akan diberikan pinjaman. *Di sini n' a (1) mewakili jumlah anggota faset *a* yang mendapatkan hasil prediksi positif dan n a adalah jumlah anggota faset a.*
+ q' d = n' d (1) /n d adalah proporsi yang diprediksi dari segi *d* a yang mendapatkan hasil positif dari nilai 1. Dalam contoh kita, aspek orang tua dan muda diprediksi akan diberikan pinjaman. *Di sini n' d (1) mewakili jumlah anggota faset *d* yang mendapatkan hasil prediksi positif dan n d adalah jumlah anggota segi d.*
Untuk biner, aspek multikategori, dan label kontinu, nilai DI berkisar selama interval [0, ∞).
+ *Nilai kurang dari 1 menunjukkan bahwa faset *a* memiliki proporsi hasil positif yang diprediksi lebih tinggi daripada segi d.* Ini disebut sebagai *bias positif*.
+ Nilai 1 menunjukkan paritas demografis.
+ *Nilai yang lebih besar dari 1 menunjukkan bahwa faset *d* memiliki proporsi hasil positif yang diprediksi lebih tinggi daripada segi a.* Ini disebut sebagai *bias negatif*.
# Perbedaan Penerimaan Bersyarat () DCAcc
Metrik ini membandingkan label yang diamati dengan label yang diprediksi oleh model dan menilai apakah ini sama di seluruh aspek untuk hasil positif yang diprediksi. Metrik ini hampir meniru bias manusia karena mengukur berapa banyak lagi hasil positif yang diprediksi model (label y') untuk aspek tertentu dibandingkan dengan apa yang diamati dalam kumpulan data pelatihan (label y). Misalnya, jika ada lebih banyak penerimaan (hasil positif) yang diamati dalam kumpulan data pelatihan untuk aplikasi pinjaman untuk kelompok paruh baya (aspek *a*) daripada yang diprediksi oleh model berdasarkan kualifikasi dibandingkan dengan aspek yang mengandung kelompok usia lain (aspek *d*), ini mungkin menunjukkan potensi bias dalam cara pinjaman disetujui untuk mendukung kelompok paruh baya.
Rumus untuk perbedaan penerimaan bersyarat:
DCAcc = c a - c d
Di mana:
+ *c a = n a (1)/n' a (1) adalah rasio jumlah hasil positif yang diamati dari nilai 1 (penerimaan) dari segi *a* terhadap jumlah hasil positif yang diprediksi (akseptansi) untuk segi a.*
+ *c d = n d (1)/n' d (1) adalah rasio jumlah hasil positif yang diamati dari nilai 1 (akseptansi) dari segi *d* dengan jumlah prediksi hasil positif yang diprediksi (penerimaan) untuk segi d.*
DCAcc Metrik dapat menangkap bias positif dan negatif yang mengungkapkan perlakuan preferensial berdasarkan kualifikasi. Pertimbangkan contoh bias berbasis usia berikut pada penerimaan pinjaman.
**Contoh 1: Bias positif**
*Misalkan kita memiliki kumpulan data 100 orang paruh baya (segi *a*) dan 50 orang dari kelompok usia lain (segi *d*) yang mengajukan pinjaman, di mana model merekomendasikan agar 60 dari segi *a* dan 30 dari segi d diberikan pinjaman.* *Jadi proporsi yang diprediksi tidak bias sehubungan dengan metrik DPPL, tetapi label yang diamati menunjukkan bahwa 70 dari segi *a* dan 20 dari segi d diberikan pinjaman.* Dengan kata lain, model memberikan pinjaman hingga 17% lebih sedikit dari segi paruh baya daripada label yang diamati dalam data pelatihan yang disarankan (70/60 = 1,17) dan memberikan pinjaman kepada 33% lebih banyak dari kelompok usia lain daripada label yang diamati disarankan (20/30 = 0,67). Perhitungan DCAcc nilai memberikan yang berikut:
DCAcc = 70/60 - 20/30 = 1/2
Nilai positif menunjukkan bahwa ada bias potensial terhadap aspek paruh baya *a* dengan tingkat penerimaan yang lebih rendah dibandingkan dengan aspek lain *d* daripada yang ditunjukkan oleh data yang diamati (dianggap tidak bias).
**Contoh 2: Bias negatif**
*Misalkan kita memiliki kumpulan data 100 orang paruh baya (segi *a*) dan 50 orang dari kelompok usia lain (segi *d*) yang mengajukan pinjaman, di mana model merekomendasikan agar 60 dari segi *a* dan 30 dari segi d diberikan pinjaman.* *Jadi proporsi yang diprediksi tidak bias sehubungan dengan metrik DPPL, tetapi label yang diamati menunjukkan bahwa 50 dari segi *a* dan 40 dari segi d diberikan pinjaman.* Dengan kata lain, model memberikan pinjaman hingga 17% lebih sedikit dari segi paruh baya daripada label yang diamati dalam data pelatihan yang disarankan (50/60 = 0,83), dan memberikan pinjaman kepada 33% lebih banyak dari kelompok usia lain daripada label yang diamati disarankan (40/30 = 1,33). Perhitungan DCAcc nilai memberikan yang berikut:
DCAcc = 50/60 - 40/30 = -1/2
Nilai negatif menunjukkan bahwa ada bias potensial terhadap segi *d* dengan tingkat penerimaan yang lebih rendah dibandingkan dengan aspek paruh baya *a daripada yang* ditunjukkan oleh data yang diamati (dianggap tidak bias).
Perhatikan bahwa Anda dapat menggunakan DCAcc untuk membantu Anda mendeteksi potensi bias (tidak disengaja) oleh manusia yang mengawasi prediksi model dalam suatu pengaturan. human-in-the-loop Asumsikan, misalnya, bahwa prediksi y' oleh model tidak bias, tetapi keputusan akhirnya dibuat oleh manusia (mungkin dengan akses ke fitur tambahan) yang dapat mengubah prediksi model untuk menghasilkan versi baru dan final dari y'. Pemrosesan tambahan oleh manusia mungkin secara tidak sengaja menolak pinjaman ke nomor yang tidak proporsional dari satu sisi. DCAccdapat membantu mendeteksi potensi bias tersebut.
Kisaran nilai untuk perbedaan penerimaan bersyarat untuk biner, aspek multikategori, dan label kontinu adalah (-∞, \$1∞).
+ *Nilai positif terjadi ketika rasio jumlah penerimaan yang diamati dibandingkan dengan akseptansi yang diprediksi untuk faset *a* lebih tinggi dari rasio yang sama untuk segi d.* *Nilai-nilai ini menunjukkan kemungkinan bias terhadap pelamar yang memenuhi syarat dari segi a.* Semakin besar perbedaan rasio, semakin ekstrim bias yang tampak.
+ *Nilai mendekati nol terjadi ketika rasio jumlah penerimaan yang diamati dibandingkan dengan akseptansi yang diprediksi untuk faset *a* mirip dengan rasio untuk segi d.* Nilai-nilai ini menunjukkan bahwa tingkat penerimaan yang diprediksi konsisten dengan nilai yang diamati dalam data berlabel dan bahwa pelamar yang memenuhi syarat dari kedua aspek diterima dengan cara yang sama.
+ *Nilai negatif terjadi ketika rasio jumlah penerimaan yang diamati dibandingkan dengan akseptansi yang diprediksi untuk faset *a* kurang dari rasio untuk segi d.* *Nilai-nilai ini menunjukkan kemungkinan bias terhadap pelamar yang memenuhi syarat dari segi d.* Semakin negatif perbedaan rasio, semakin ekstrim bias yang tampak.
# Perbedaan Penolakan Bersyarat (DCR)
Metrik ini membandingkan label yang diamati dengan label yang diprediksi oleh model dan menilai apakah ini sama di seluruh aspek untuk hasil negatif (penolakan). Metrik ini mendekati meniru bias manusia, dalam hal itu mengukur berapa banyak lagi hasil negatif yang diberikan model (label yang diprediksi y') ke aspek tertentu dibandingkan dengan apa yang disarankan oleh label dalam kumpulan data pelatihan (label yang diamati y). Misalnya, jika ada lebih banyak penolakan yang diamati (hasil negatif) untuk aplikasi pinjaman untuk kelompok paruh baya (aspek *a*) daripada yang diprediksi oleh model berdasarkan kualifikasi dibandingkan dengan aspek yang mengandung kelompok usia lain (segi *d*), ini mungkin menunjukkan potensi bias dalam cara pinjaman ditolak yang lebih disukai kelompok paruh baya daripada kelompok lain.
Rumus untuk perbedaan penerimaan bersyarat:
DCR = r - r d a
Di mana:
+ *r d = n d (0)/n' d (0) adalah rasio jumlah hasil negatif yang diamati dari nilai 0 (penolakan) dari segi *d* terhadap jumlah prediksi hasil negatif (penolakan) untuk segi d.*
+ *r a = n a (0)/n' a (0) adalah rasio jumlah hasil negatif yang diamati dari nilai 0 (penolakan) dari segi *a* terhadap jumlah prediksi hasil negatif dari nilai 0 (penolakan) untuk segi a.*
Metrik DCR dapat menangkap bias positif dan negatif yang mengungkapkan perlakuan preferensial berdasarkan kualifikasi. Pertimbangkan contoh bias berbasis usia berikut pada penolakan pinjaman.
**Contoh 1: Bias positif**
*Misalkan kita memiliki kumpulan data 100 orang paruh baya (segi *a*) dan 50 orang dari kelompok usia lain (segi *d*) yang mengajukan pinjaman, di mana model merekomendasikan bahwa 60 dari segi *a* dan 30 dari segi d ditolak untuk pinjaman.* *Jadi proporsi yang diprediksi tidak bias oleh metrik DPPL, tetapi label yang diamati menunjukkan bahwa 50 dari segi *a* dan 40 dari segi d ditolak.* Dengan kata lain, model menolak 17% lebih banyak pinjaman dari segi paruh baya daripada label yang diamati dalam data pelatihan yang disarankan (50/60 = 0,83), dan menolak pinjaman 33% lebih sedikit dari kelompok usia lain daripada label yang diamati yang disarankan (40/30 = 1,33). Nilai DCR mengukur perbedaan ini dalam rasio tingkat penolakan yang diamati terhadap prediksi antar aspek. Nilai positif menunjukkan bahwa ada bias potensial yang mendukung kelompok paruh baya dengan tingkat penolakan yang lebih rendah dibandingkan dengan kelompok lain daripada yang ditunjukkan oleh data yang diamati (dianggap tidak bias).
DCR = 40/30 - 50/60 = 1/2
**Contoh 2: Bias negatif**
*Misalkan kita memiliki kumpulan data 100 orang paruh baya (segi *a*) dan 50 orang dari kelompok usia lain (segi *d*) yang mengajukan pinjaman, di mana model merekomendasikan bahwa 60 dari segi *a* dan 30 dari segi d ditolak untuk pinjaman.* *Jadi proporsi yang diprediksi tidak bias oleh metrik DPPL, tetapi label yang diamati menunjukkan bahwa 70 dari segi *a* dan 20 dari segi d ditolak.* Dengan kata lain, model menolak pinjaman 17% lebih sedikit dari segi paruh baya daripada label yang diamati dalam data pelatihan yang disarankan (70/60 = 1,17), dan menolak 33% lebih banyak pinjaman dari kelompok usia lain daripada label yang diamati yang disarankan (20/30 = 0,67). Nilai negatif menunjukkan bahwa ada bias potensial yang mendukung aspek *a* dengan tingkat penolakan yang lebih rendah dibandingkan dengan aspek paruh baya *a daripada yang* ditunjukkan oleh data yang diamati (dianggap tidak bias).
DCR = 20/30 - 70/60 = -1/2
Kisaran nilai untuk perbedaan penolakan bersyarat untuk biner, aspek multikategori, dan label kontinu adalah (-∞, \$1∞).
+ *Nilai positif terjadi ketika rasio jumlah penolakan yang diamati dibandingkan dengan prediksi penolakan untuk segi *d* lebih besar dari rasio untuk faset a.* *Nilai-nilai ini menunjukkan kemungkinan bias terhadap pelamar yang memenuhi syarat dari segi a.* Semakin besar nilai metrik DCR, semakin ekstrem bias yang tampak.
+ *Nilai mendekati nol terjadi ketika rasio jumlah penolakan yang diamati dibandingkan dengan penerimaan yang diprediksi untuk faset *a* mirip dengan rasio untuk segi d.* Nilai-nilai ini menunjukkan bahwa tingkat penolakan yang diprediksi konsisten dengan nilai yang diamati dalam data berlabel dan bahwa pelamar yang memenuhi syarat dari kedua aspek ditolak dengan cara yang sama.
+ *Nilai negatif terjadi ketika rasio jumlah penolakan yang diamati dibandingkan dengan prediksi penolakan untuk segi *d* kurang dari aspek rasio a.* *Nilai-nilai ini menunjukkan kemungkinan bias terhadap pelamar yang memenuhi syarat dari segi d.* Semakin besar besarnya metrik DCR negatif, semakin ekstrem bias yang tampak.
# Perbedaan spesifisitas (SD)
*Perbedaan spesifisitas (SD) adalah perbedaan spesifisitas antara faset yang disukai *a dan aspek yang* tidak disukai d.* Spesifisitas mengukur seberapa sering model memprediksi hasil negatif dengan benar (y'=0). Setiap perbedaan dalam kekhususan ini adalah bentuk bias potensial.
Spesifisitas sempurna untuk suatu segi jika semua kasus y=0 diprediksi dengan benar untuk segi tersebut. Spesifisitas lebih besar ketika model meminimalkan positif palsu, yang dikenal sebagai kesalahan Tipe I. *Misalnya, perbedaan antara spesifisitas rendah untuk pinjaman ke segi *a*, dan spesifisitas tinggi untuk pinjaman ke segi *d, adalah ukuran bias terhadap segi d*.*
*Rumus berikut adalah untuk perbedaan spesifisitas untuk segi *a dan d*.*
SD = TNd/(dTN\$1FPd) - TNa/(aaTN\$1FP) = TNR - TNR d a
Variabel berikut yang digunakan untuk menghitung SD didefinisikan sebagai berikut:
+ *TN d adalah negatif sebenarnya yang diprediksi untuk segi d.*
+ *FP d adalah positif palsu yang diprediksi untuk segi d.*
+ *TN d adalah negatif sebenarnya yang diprediksi untuk aspek a.*
+ *FP d adalah positif palsu yang diprediksi untuk segi a.*
+ *TNR a = TNa/(aTN\$1FPa) adalah tingkat negatif sebenarnya, juga dikenal sebagai spesifisitas, untuk segi a.*
+ *TNR d = TNd/(dTN\$1FPd) adalah tingkat negatif sebenarnya, juga dikenal sebagai spesifisitas, untuk segi d.*
*Misalnya, perhatikan matriks kebingungan berikut untuk segi *a* dan d.*
Matriks kebingungan untuk segi yang disukai `a`
| Prediksi kelas a | Hasil aktual 0 | Hasil aktual 1 | Total |
| --- | --- | --- | --- |
| 0 | 20 | 5 | 25 |
| 1 | 10 | 65 | 75 |
| Total | 30 | 70 | 100 |
Matriks kebingungan untuk segi yang tidak disukai `d`
| Prediksi kelas d | Hasil aktual 0 | Hasil aktual 1 | Total |
| --- | --- | --- | --- |
| 0 | 18 | 7 | 25 |
| 1 | 5 | 20 | 25 |
| Total | 23 | 27 | 50 |
*Nilai perbedaan spesifisitas adalah`SD = 18/(18+5) - 20/(20+10) = 0.7826 - 0.6667 = 0.1159`, yang menunjukkan bias terhadap segi d.*
Rentang nilai untuk perbedaan spesifisitas antara aspek *a* dan *d* untuk klasifikasi biner dan multikategori adalah. `[-1, +1]` Metrik ini tidak tersedia untuk kasus label kontinu. Inilah yang disiratkan oleh nilai-nilai SD yang berbeda:
+ *Nilai positif diperoleh ketika ada spesifisitas yang lebih tinggi untuk faset *d* daripada faset a.* *Ini menunjukkan bahwa model menemukan lebih sedikit positif palsu untuk faset *d* daripada untuk faset a.* Nilai positif menunjukkan bias terhadap segi *d*.
+ Nilai mendekati nol menunjukkan bahwa spesifisitas untuk segi yang dibandingkan serupa. Ini menunjukkan bahwa model menemukan jumlah positif palsu yang sama di kedua aspek ini dan tidak bias.
+ *Nilai negatif diperoleh ketika ada spesifisitas yang lebih tinggi untuk faset *a* daripada faset d.* *Ini menunjukkan bahwa model menemukan lebih banyak positif palsu untuk faset *a* daripada untuk segi d.* Nilai negatif menunjukkan bias terhadap segi *a*.
# Ingat Perbedaan (RD)
*Metrik recall difference (RD) adalah perbedaan dalam mengingat model antara faset yang disukai *a dan aspek yang* tidak disukai d.* Setiap perbedaan dalam penarikan ini adalah bentuk bias potensial. Ingat adalah tingkat positif sejati (TPR), yang mengukur seberapa sering model memprediksi dengan benar kasus-kasus yang seharusnya menerima hasil positif. Ingat sempurna untuk suatu segi jika semua kasus y=1 diprediksi dengan benar sebagai y'=1 untuk segi itu. Ingat lebih besar ketika model meminimalkan negatif palsu yang dikenal sebagai kesalahan Tipe II. Misalnya, berapa banyak orang dalam dua kelompok berbeda (aspek *a* dan *d*) yang harus memenuhi syarat untuk pinjaman terdeteksi dengan benar oleh model? *Jika tingkat penarikan tinggi untuk pinjaman ke segi *a*, tetapi rendah untuk pinjaman ke segi *d*, perbedaannya memberikan ukuran bias ini terhadap kelompok yang termasuk dalam segi d.*
Rumus untuk perbedaan tingkat penarikan untuk aspek *a* dan *d*:
RD = TPa/(TP a \$1 FNa) - TPd/(TP d \$1 FN) = TPR - TPR d a d
Di mana:
+ *TP a adalah positif sejati yang diprediksi untuk aspek a.*
+ *FN a adalah negatif palsu yang diprediksi untuk segi a.*
+ *TP d adalah positif sejati yang diprediksi untuk segi d.*
+ *FN d adalah negatif palsu yang diprediksi untuk segi d.*
+ TPR a = TPa/(TP a \$1 FNa) adalah penarikan untuk faset *a*, atau tingkat positif sebenarnya.
+ TPR d TPd/(TP d \$1 FNd) adalah penarikan untuk segi *d*, atau tingkat positif sebenarnya.
*Misalnya, perhatikan matriks kebingungan berikut untuk segi *a* dan d.*
Matriks Kebingungan untuk Aspek Favorit a
| Prediksi kelas a | Hasil aktual 0 | Hasil aktual 1 | Total |
| --- | --- | --- | --- |
| 0 | 20 | 5 | 25 |
| 1 | 10 | 65 | 75 |
| Total | 30 | 70 | 100 |
Matriks Kebingungan untuk Aspet yang Tidak Disukai d
| Prediksi kelas d | Hasil aktual 0 | Hasil aktual 1 | Total |
| --- | --- | --- | --- |
| 0 | 18 | 7 | 25 |
| 1 | 5 | 20 | 25 |
| Total | 23 | 27 | 50 |
*Nilai perbedaan recall adalah RD = 65/70 - 20/27 = 0,93 - 0,74 = 0,19 yang menunjukkan bias terhadap segi d.*
Rentang nilai untuk perbedaan ingatan antara segi *a* dan *d* untuk klasifikasi biner dan multikategori adalah [-1, \$11]. Metrik ini tidak tersedia untuk kasus label kontinu.
+ *Nilai positif diperoleh ketika ada ingatan yang lebih tinggi untuk faset *a* daripada untuk segi d.* Hal ini menunjukkan bahwa model menemukan lebih banyak hal positif sejati untuk faset *a* daripada segi *d*, yang merupakan bentuk bias.
+ Nilai mendekati nol menunjukkan bahwa penarikan kembali untuk aspek yang dibandingkan serupa. Ini menunjukkan bahwa model menemukan jumlah positif sejati yang sama di kedua aspek ini dan tidak bias.
+ *Nilai negatif diperoleh ketika ada ingatan yang lebih tinggi untuk faset *d* daripada faset a.* Ini menunjukkan bahwa model menemukan lebih banyak hal positif sejati untuk segi *d* daripada faset *a*, yang merupakan bentuk bias.
# Perbedaan Tingkat Penerimaan (DAR)
**Perbedaan metrik tingkat penerimaan (DAR) adalah perbedaan rasio prediksi positif sejati (TP) terhadap positif yang diamati (TP \$1 FP) untuk aspek a dan d.** Metrik ini mengukur perbedaan presisi model untuk memprediksi penerimaan dari kedua aspek ini. Presisi mengukur fraksi kandidat yang memenuhi syarat dari kumpulan kandidat yang memenuhi syarat yang diidentifikasi oleh model. Jika presisi model untuk memprediksi pelamar yang memenuhi syarat berbeda antar aspek, ini adalah bias dan besarnya diukur oleh DAR.
Rumus untuk perbedaan tingkat penerimaan antara aspek *a* dan *d*:
DAR = TPa/(TP a \$1FPa) - TPd/(TP \$1FP) d d
Di mana:
+ *TP a adalah positif sejati yang diprediksi untuk aspek a.*
+ *FP a adalah positif palsu yang diprediksi untuk segi a.*
+ *TP d adalah positif sejati yang diprediksi untuk segi d.*
+ *FP d adalah positif palsu yang diprediksi untuk segi d.*
Misalnya, model menerima 70 pelamar paruh baya (aspek *a*) untuk pinjaman (label positif yang diprediksi) yang hanya 35 yang benar-benar diterima (label positif yang diamati). Juga misalkan model menerima 100 pelamar dari demografi usia lain (segi *d*) untuk pinjaman (label positif yang diprediksi) di antaranya hanya 40 yang benar-benar diterima (label positif yang diamati). *Kemudian DAR = 35/70 - 40/100 = 0,10, yang menunjukkan potensi bias terhadap orang-orang yang memenuhi syarat dari kelompok usia kedua (segi d).*
Rentang nilai DAR untuk biner, aspek multikategori, dan label kontinu adalah [-1, \$11].
+ *Nilai positif terjadi ketika rasio positif yang diprediksi (penerimaan) terhadap hasil positif yang diamati (pelamar yang memenuhi syarat) untuk aspek *a* lebih besar dari rasio yang sama untuk segi d.* *Nilai-nilai ini menunjukkan kemungkinan bias terhadap aspek yang tidak disukai *d* yang disebabkan oleh terjadinya positif palsu yang relatif lebih banyak di segi d.* Semakin besar perbedaan rasio, semakin ekstrim bias yang tampak.
+ Nilai mendekati nol terjadi ketika rasio positif yang diprediksi (penerimaan) terhadap hasil positif yang diamati (pelamar yang memenuhi syarat) untuk aspek *a* dan *d* memiliki nilai serupa yang menunjukkan label yang diamati untuk hasil positif diprediksi dengan presisi yang sama oleh model.
+ *Nilai negatif terjadi ketika rasio positif yang diprediksi (penerimaan) terhadap hasil positif yang diamati (pelamar yang memenuhi syarat) untuk aspek *d* lebih besar dari aspek rasio a.* *Nilai-nilai ini menunjukkan kemungkinan bias terhadap aspek yang disukai *a yang* disebabkan oleh terjadinya positif yang relatif lebih palsu dalam segi a.* Semakin negatif perbedaan rasio, semakin ekstrim bias yang tampak.
# Perbedaan Tingkat Penolakan (DRR)
**Perbedaan metrik tingkat penolakan (DRR) adalah perbedaan rasio prediksi negatif sejati (TN) terhadap negatif yang diamati (TN\$1FN) untuk aspek a dan d.** Metrik ini mengukur perbedaan presisi model untuk memprediksi penolakan dari kedua aspek ini. Presisi mengukur fraksi kandidat yang tidak memenuhi syarat dari kumpulan kandidat yang tidak memenuhi syarat yang diidentifikasi seperti itu oleh model. Jika presisi model untuk memprediksi pelamar yang tidak memenuhi syarat berbeda antar aspek, ini adalah bias dan besarnya diukur oleh DRR.
Rumus untuk perbedaan tingkat penolakan antara segi *a* dan *d*:
DRR = TNd/(dTN\$1FNd) - TNa/(TN\$1FN) a a
Komponen untuk persamaan DRR sebelumnya adalah sebagai berikut.
+ *TN d adalah negatif sebenarnya yang diprediksi untuk segi d.*
+ *FN d adalah negatif palsu yang diprediksi untuk segi d.*
+ *TP a adalah negatif sebenarnya yang diprediksi untuk aspek a.*
+ *FN a adalah negatif palsu yang diprediksi untuk segi a.*
Misalnya, model menolak 100 pelamar paruh baya (aspek *a) untuk pinjaman (label negatif yang* diprediksi) di antaranya 80 sebenarnya tidak memenuhi syarat (label negatif yang diamati). Juga misalkan model menolak 50 pelamar dari demografi usia lain (segi *d*) untuk pinjaman (label negatif yang diprediksi) di antaranya hanya 40 yang benar-benar tidak memenuhi syarat (label negatif yang diamati). Kemudian DRR = 40/50 - 80/100 = 0, jadi tidak ada bias yang ditunjukkan.
Rentang nilai DRR untuk biner, aspek multikategori, dan label kontinu adalah [-1, \$11].
+ *Nilai positif terjadi ketika rasio negatif yang diprediksi (penolakan) terhadap hasil negatif yang diamati (pelamar yang tidak memenuhi syarat) untuk aspek *d* lebih besar dari rasio yang sama untuk aspek a.* *Nilai-nilai ini menunjukkan kemungkinan bias terhadap aspek yang disukai *a yang* disebabkan oleh terjadinya negatif yang relatif lebih salah dalam aspek a.* Semakin besar perbedaan rasio, semakin ekstrim bias yang tampak.
+ Nilai mendekati nol terjadi ketika rasio negatif yang diprediksi (penolakan) terhadap hasil negatif yang diamati (pelamar yang tidak memenuhi syarat) untuk aspek *a* dan *d* memiliki nilai yang sama, menunjukkan label yang diamati untuk hasil negatif diprediksi dengan presisi yang sama oleh model.
+ *Nilai negatif terjadi ketika rasio negatif yang diprediksi (penolakan) terhadap hasil negatif yang diamati (pelamar yang tidak memenuhi syarat) untuk aspek *a* lebih besar dari aspek rasio d.* *Nilai-nilai ini menunjukkan kemungkinan bias terhadap aspek yang tidak disukai *d* yang disebabkan oleh terjadinya positif palsu yang relatif lebih banyak di segi d.* Semakin negatif perbedaan rasio, semakin ekstrim bias yang tampak.
# Perbedaan Akurasi (AD)
Metrik perbedaan akurasi (AD) adalah perbedaan antara akurasi prediksi untuk berbagai aspek. Metrik ini menentukan apakah klasifikasi menurut model lebih akurat untuk satu aspek daripada yang lain. AD menunjukkan apakah satu aspek menimbulkan proporsi kesalahan Tipe I dan Tipe II yang lebih besar. Tetapi tidak dapat membedakan antara kesalahan Tipe I dan Tipe II. Misalnya, model mungkin memiliki akurasi yang sama untuk demografi usia yang berbeda, tetapi kesalahan mungkin sebagian besar positif palsu (kesalahan Tipe I) untuk satu kelompok berbasis usia dan sebagian besar negatif palsu (kesalahan Tipe II) untuk yang lain.
Juga, jika persetujuan pinjaman dibuat dengan akurasi yang jauh lebih tinggi untuk demografis paruh baya (aspek *a*) daripada demografis berbasis usia lainnya (aspek *d*), proporsi yang lebih besar dari pelamar yang memenuhi syarat di kelompok kedua ditolak pinjaman (FN) atau proporsi yang lebih besar dari pelamar yang tidak memenuhi syarat dari kelompok itu mendapatkan pinjaman (FP) atau keduanya. Hal ini dapat menyebabkan ketidakadilan kelompok untuk kelompok kedua, bahkan jika proporsi pinjaman yang diberikan hampir sama untuk kedua kelompok berbasis usia, yang ditunjukkan oleh nilai DPPL yang mendekati nol.
*Rumus untuk metrik AD adalah perbedaan antara akurasi prediksi untuk facet *a*, ACC, dikurangi untuk facet da, ACC:* d
IKLAN = ACC a - ACC d
Di mana:
+ ACC a = (TP a \$1 TNa)/(TP \$1 a TN\$1FP\$1FNa) a a
+ *TP a adalah positif sejati yang diprediksi untuk segi a*
+ *TN a adalah negatif sebenarnya yang diprediksi untuk segi a*
+ *FP a adalah positif palsu yang diprediksi untuk segi a*
+ *FN a adalah negatif palsu yang diprediksi untuk segi a*
+ ACC d = (TP d \$1 TNd)/(TP \$1 d TN\$1FP\$1FNd) d d
+ *TP d adalah positif sejati yang diprediksi untuk segi d*
+ *TN d adalah negatif sebenarnya yang diprediksi untuk segi d*
+ *FP d adalah positif palsu yang diprediksi untuk segi d*
+ *FN d adalah negatif palsu yang diprediksi untuk segi d*
Misalnya, model menyetujui pinjaman kepada 70 pelamar dari segi *a* 100 dan menolak 30 lainnya. 10 seharusnya tidak ditawari pinjaman (FPa) dan 60 disetujui yang seharusnya (TP). 20 penolakan seharusnya disetujui (FNa) dan 10 ditolak dengan benar (TNa). a Akurasi untuk segi *a* adalah sebagai berikut:
ACC a = (60 \$1 10)/(60 \$1 10 \$1 20 \$1 10) = 0,7
Selanjutnya, misalkan model menyetujui pinjaman kepada 50 pelamar dari segi *d* 100 dan menolak 50 lainnya. 10 seharusnya tidak ditawari pinjaman (FPa) dan 40 disetujui yang seharusnya (TPa). 40 penolakan seharusnya disetujui (FN) dan 10 ditolak dengan benar (TNa). a Keakuratan untuk faset *a* ditentukan sebagai berikut:
ACC d = (40 \$1 10)/(40 \$1 10 \$1 40 \$1 10) = 0,5
Perbedaan akurasi dengan demikian AD = ACC a - ACC d = 0,7 - 0,5 = 0,2. Ini menunjukkan ada bias terhadap segi *d* karena metriknya positif.
Rentang nilai untuk AD untuk label faset biner dan multikategori adalah [-1, \$11].
+ *Nilai positif terjadi ketika akurasi prediksi untuk faset *a* lebih besar dari segi d.* Ini berarti bahwa facet *d* lebih menderita dari beberapa kombinasi positif palsu (kesalahan Tipe I) atau negatif palsu (kesalahan Tipe II). *Ini berarti ada bias potensial terhadap aspek yang tidak disukai d.*
+ *Nilai mendekati nol terjadi ketika akurasi prediksi untuk faset *a* mirip dengan faset d.*
+ *Nilai negatif terjadi ketika akurasi prediksi untuk faset *d* lebih besar dari segi a t.* Ini berarti bahwa facet *a* lebih menderita dari beberapa kombinasi positif palsu (kesalahan Tipe I) atau negatif palsu (kesalahan Tipe II). *Ini berarti bias terhadap aspek yang disukai a.*
# Kesetaraan Perawatan (TE)
**Kesetaraan perlakuan (TE) adalah perbedaan rasio negatif palsu terhadap positif palsu antara aspek a dan d.** Gagasan utama dari metrik ini adalah untuk menilai apakah, bahkan jika akurasi antar kelompok sama, apakah kesalahan lebih berbahaya bagi satu kelompok daripada yang lain? Tingkat kesalahan berasal dari total positif palsu dan negatif palsu, tetapi rincian keduanya mungkin sangat berbeda di seluruh aspek. TE mengukur apakah kesalahan mengkompensasi dengan cara yang serupa atau berbeda di seluruh aspek.
Rumus untuk kesetaraan pengobatan:
TE = FN d /FP - FN /FP d a a
Di mana:
+ *FN d adalah negatif palsu yang diprediksi untuk segi d.*
+ *FP d adalah positif palsu yang diprediksi untuk segi d.*
+ *FN a adalah negatif palsu yang diprediksi untuk segi a.*
+ *FP a adalah positif palsu yang diprediksi untuk segi a.*
Perhatikan metrik menjadi tidak terbatas jika FP a atau d FP adalah nol.
*Misalnya, anggaplah ada 100 pemohon pinjaman dari segi *a* dan 50 dari segi d.* Untuk segi *a*, 8 salah ditolak pinjaman (FNa) dan 6 lainnya salah disetujui (FP). a Prediksi yang tersisa benar, jadi TP a \$1 TN a = 86. Untuk segi *d*, 5 ditolak secara salah (FNd) dan 2 disetujui secara salah (FP). d Prediksi yang tersisa benar, jadi TP d \$1 TN d = 43. *Rasio negatif palsu terhadap positif palsu sama dengan 8/6 = 1,33 untuk faset *a* dan 5/2 = 2,5 untuk segi d.* Oleh karena itu TE = 2.5 - 1.33 = 1.167, meskipun kedua segi memiliki akurasi yang sama:
ACC a = (86)/(86\$1 8 \$1 6) = 0,86
ACC d = (43)/(43 \$1 5 \$1 2) = 0,86
Kisaran nilai untuk perbedaan penolakan bersyarat untuk label faset biner dan multikategori adalah (-∞, \$1∞). Metrik TE tidak didefinisikan untuk label kontinu. Interpretasi metrik ini tergantung pada relatif penting dari positif palsu (Kesalahan tipe I) dan negatif palsu (kesalahan Tipe II).
+ *Nilai positif terjadi ketika rasio negatif palsu terhadap positif palsu untuk faset *d* lebih besar daripada untuk faset a.*
+ *Nilai mendekati nol terjadi ketika rasio negatif palsu terhadap positif palsu untuk faset *a* mirip dengan rasio untuk faset d.*
+ *Nilai negatif terjadi ketika rasio negatif palsu terhadap positif palsu untuk faset *d* kurang dari untuk faset a.*
**catatan**
Versi sebelumnya menyatakan bahwa metrik Perlakuan Kesetaraan dihitung sebagai FP/FN - a FP/FN d bukan d FN/FP a - d FN/FP. d a a Sementara salah satu versi dapat digunakan. Untuk informasi selengkapnya, lihat [https://pages.awscloud.com/rs/112-TZM-766/images/Fairness.Measures.for.Machine.Learning.in.Finance.pdf](https://pages.awscloud.com/rs/112-TZM-766/images/Fairness.Measures.for.Machine.Learning.in.Finance.pdf).
# Disparitas Demografis Bersyarat dalam Label yang Diprediksi (CDDPL)
Metrik disparitas demografis (DDPL) menentukan apakah aspek *d* memiliki proporsi yang lebih besar dari label yang ditolak yang diprediksi daripada label yang diterima yang diprediksi. Ini memungkinkan perbandingan perbedaan dalam proporsi penolakan yang diprediksi dan proporsi penerimaan yang diprediksi di seluruh aspek. Metrik ini persis sama dengan metrik CDD pra-pelatihan kecuali bahwa itu dihitung dari label yang diprediksi alih-alih yang diamati. Metrik ini terletak pada kisaran (-1, \$11).
*Rumus prediksi disparitas demografis untuk label segi d adalah sebagai berikut:*
DDPL d = n' d (0) /n '(0) - n' d (1) /n' (1) = P d R (y' 0) - P A (y' 1) d
Di mana:
+ **n' (0) = n' a (0) \$1 n' d (0) adalah jumlah label yang ditolak yang diprediksi untuk segi a dan d.**
+ **n' (1) = n' a (1) \$1 n' d (1) adalah jumlah label yang diterima yang diprediksi untuk segi a dan d.**
+ *P d R (y' 0) adalah proporsi label ditolak yang diprediksi (nilai 0) dalam segi d.*
+ *P d A (y' 1) adalah proporsi label yang diterima yang diprediksi (nilai 1) dalam segi d.*
Metrik disparitas demografis bersyarat dalam label prediksi (CDDPL) yang mengkondisikan DDPL pada atribut yang menentukan strata subkelompok pada kumpulan data diperlukan untuk mengesampingkan paradoks Simpson. Pengelompokan kembali dapat memberikan wawasan tentang penyebab kesenjangan demografis yang jelas untuk aspek yang kurang disukai. Kasus klasik muncul dalam kasus penerimaan Berkeley di mana pria diterima pada tingkat yang lebih tinggi secara keseluruhan daripada wanita. Tetapi ketika subkelompok departemen diperiksa, wanita terbukti memiliki tingkat penerimaan yang lebih tinggi daripada pria berdasarkan departemen. Penjelasannya adalah bahwa wanita telah mendaftar ke departemen dengan tingkat penerimaan yang lebih rendah daripada pria. Meneliti tingkat penerimaan subkelompok mengungkapkan bahwa wanita sebenarnya diterima pada tingkat yang lebih tinggi daripada pria untuk departemen dengan tingkat penerimaan yang lebih rendah.
Metrik CDDPL memberikan ukuran tunggal untuk semua perbedaan yang ditemukan dalam subkelompok yang ditentukan oleh atribut kumpulan data dengan meratakannya. Ini didefinisikan sebagai rata-rata tertimbang disparitas demografis dalam label prediksi (DDPLi) untuk masing-masing subkelompok, dengan setiap disparitas subkelompok tertimbang secara proporsional dengan jumlah pengamatan dalam mengandung. Rumus untuk disparitas demografis bersyarat dalam label yang diprediksi adalah sebagai berikut:
CDDPL = (1/n) \$1 Σ n DDPL i i \$1 i
Di mana:
+ in i = n adalah jumlah total pengamatan dan n i adalah jumlah pengamatan untuk setiap subkelompok.
+ DDPL i = n' i (0) /n (0) - n' i (1) /n (1) = P i R (y' 0) - P i A (y' 1) adalah perbedaan demografis dalam label yang diprediksi untuk subkelompok.
Jadi perbedaan demografis untuk subkelompok dalam label prediksi (DDPLi) adalah perbedaan antara proporsi label yang ditolak yang diprediksi dan proporsi label yang diterima yang diprediksi untuk setiap subkelompok.
Kisaran nilai DDPL untuk hasil biner, multikategori, dan kontinu adalah [-1, \$11].
+ *\$11: ketika tidak ada label penolakan yang diprediksi untuk faset *a* atau subkelompok dan tidak ada penerimaan yang diprediksi untuk segi d atau subkelompok.*
+ Nilai positif menunjukkan ada perbedaan demografis dalam label yang diprediksi karena aspek *d* atau subkelompok memiliki proporsi yang lebih besar dari label yang ditolak yang diprediksi daripada label yang diterima yang diprediksi. Semakin tinggi nilainya semakin besar disparitas.
+ Nilai mendekati nol menunjukkan tidak ada perbedaan demografis rata-rata.
+ Nilai negatif menunjukkan ada perbedaan demografis dalam label yang diprediksi karena aspek *a* atau subkelompok memiliki proporsi yang lebih besar dari label yang ditolak yang diprediksi daripada label yang diterima yang diprediksi. Semakin rendah nilainya semakin besar disparitas.
+ *-1: ketika tidak ada kerah penolakan yang diprediksi untuk segi *d* atau subkelompok dan tidak ada penerimaan yang diprediksi untuk faset a atau subkelompok.*
# Fliptest Kontrafaktual (FT)
Fliptest adalah pendekatan yang melihat setiap anggota facet *d* dan menilai apakah anggota faset yang serupa memiliki prediksi model *yang* berbeda. *Anggota faset *a* dipilih menjadi k-tetangga terdekat dari pengamatan dari segi d.* Kami menilai berapa banyak tetangga terdekat dari kelompok lawan yang menerima prediksi yang berbeda, di mana prediksi terbalik dapat berubah dari positif ke negatif dan sebaliknya.
*Rumus untuk fliptest kontrafaktual adalah perbedaan kardinalitas dua himpunan dibagi dengan jumlah anggota segi d:*
FT = (F \$1 - F -) /n d
Di mana:
+ *F \$1 = adalah jumlah anggota sisi *d* yang tidak disukai dengan hasil yang tidak menguntungkan yang tetangga terdekatnya dalam aspek yang disukai menerima hasil yang menguntungkan.*
+ *F - = adalah jumlah anggota sisi *d* yang tidak disukai dengan hasil yang menguntungkan yang tetangga terdekatnya dalam aspek yang disukai menerima hasil yang tidak menguntungkan.*
+ n d adalah ukuran sampel dari segi *d*.
Rentang nilai untuk fliptest kontrafaktual untuk label faset biner dan multikategori adalah [-1, \$11]. Untuk label kontinu, kami menetapkan ambang batas untuk menciutkan label ke biner.
+ *Nilai positif terjadi ketika jumlah keputusan terlentang kontrafaktual yang tidak menguntungkan untuk aspek yang tidak disukai d melebihi yang menguntungkan.*
+ Nilai mendekati nol terjadi ketika jumlah keputusan fliptest kontrafaktual yang tidak menguntungkan dan menguntungkan seimbang.
+ *Nilai negatif terjadi ketika jumlah keputusan terlentang kontrafaktual yang tidak menguntungkan untuk aspek yang tidak disukai d kurang dari yang menguntungkan.*
# Entropi umum (GE)
Indeks entropi umum (GE) mengukur ketidaksetaraan manfaat `b` untuk label yang diprediksi dibandingkan dengan label yang diamati. Manfaat terjadi ketika positif palsu diprediksi. Positif palsu terjadi ketika pengamatan negatif (y=0) memiliki prediksi positif (y'=1). Manfaat juga terjadi ketika label yang diamati dan diprediksi sama, juga dikenal sebagai positif sejati dan negatif sejati. Tidak ada manfaat yang terjadi ketika negatif palsu diprediksi. Negatif palsu terjadi ketika pengamatan positif (y=1) diprediksi memiliki hasil negatif (y'=0). Manfaatnya `b` didefinisikan, sebagai berikut.
```
b = y' - y + 1
```
Dengan menggunakan definisi ini, positif palsu menerima manfaat `b` dari`2`, dan negatif palsu menerima manfaat dari`0`. Baik positif sejati maupun negatif sejati menerima manfaat dari`1`.
Metrik GE dihitung mengikuti [Indeks Entropi Umum](https://en.wikipedia.org/wiki/Generalized_entropy_index) (GE) dengan bobot diatur ke. `alpha` `2` Bobot ini mengontrol sensitivitas terhadap nilai manfaat yang berbeda. Yang lebih kecil `alpha` berarti peningkatan sensitivitas terhadap nilai yang lebih kecil.
![\[Persamaan yang mendefinisikan indeks entropi umum dengan parameter alfa diatur ke 2.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/clarify-post-training-bias-metric-ge.png)
Variabel berikut yang digunakan untuk menghitung GE didefinisikan sebagai berikut:
+ b i adalah manfaat yang diterima oleh titik `ith` data.
+ b 'adalah arti dari semua manfaat.
GE dapat berkisar dari 0 hingga 0,5, di mana nilai nol menunjukkan tidak ada ketidaksetaraan manfaat di semua titik data. Ini terjadi baik ketika semua input diprediksi dengan benar atau ketika semua prediksi positif palsu. GE tidak terdefinisi ketika semua prediksi adalah negatif palsu.
**catatan**
Metrik GE tidak bergantung pada nilai faset yang disukai atau tidak disukai.
# Penjelasan Model
Amazon SageMaker Clarify menyediakan alat untuk membantu menjelaskan bagaimana model pembelajaran mesin (ML) membuat prediksi. Alat-alat ini dapat membantu pemodel dan pengembang dan pemangku kepentingan internal lainnya memahami karakteristik model secara keseluruhan sebelum penerapan dan untuk men-debug prediksi yang disediakan oleh model setelah diterapkan.
+ Untuk mendapatkan penjelasan untuk kumpulan data dan model Anda, lihat. [Keadilan, penjelasan model, dan deteksi bias dengan Clarify SageMaker](clarify-configure-processing-jobs.md)
+ Untuk mendapatkan penjelasan secara real-time dari titik akhir SageMaker AI, lihat. [Penjelasan online dengan Clarify SageMaker](clarify-online-explainability.md)
Transparansi tentang bagaimana model ML sampai pada prediksi mereka juga penting bagi konsumen dan regulator. Mereka perlu mempercayai prediksi model jika mereka akan menerima keputusan berdasarkan prediksi tersebut. SageMaker Clarify menggunakan pendekatan atribusi fitur model-agnostik. Anda dapat menggunakan ini untuk memahami mengapa model membuat prediksi setelah pelatihan, dan untuk memberikan penjelasan per contoh selama inferensi. Implementasinya mencakup implementasi [SHAP](https://papers.nips.cc/paper/2017/file/8a20a8621978632d76c43dfd28b67767-Paper.pdf) yang terukur dan efisien. Ini didasarkan pada konsep nilai Shapley, dari bidang teori permainan kooperatif, yang memberikan setiap fitur nilai penting untuk prediksi tertentu.
Clarify menghasilkan plot ketergantungan parsial (PDPs) yang menunjukkan fitur efek marjinal terhadap hasil prediksi dari model pembelajaran mesin. Ketergantungan sebagian membantu menjelaskan respons target yang diberikan serangkaian fitur input. Ini juga mendukung penjelasan visi komputer (CV) dan pemrosesan bahasa alami (NLP) menggunakan algoritma nilai Shapley (SHAP) yang sama seperti yang digunakan untuk penjelasan data tabel.
Apa fungsi penjelasan dalam konteks pembelajaran mesin? Penjelasan dapat dianggap sebagai jawaban atas *pertanyaan Mengapa* yang membantu manusia memahami penyebab prediksi. Dalam konteks model ML, Anda mungkin tertarik untuk menjawab pertanyaan seperti:
+ Mengapa model memprediksi hasil negatif seperti penolakan pinjaman untuk pemohon tertentu?
+ Bagaimana model membuat prediksi?
+ Mengapa model membuat prediksi yang salah?
+ Fitur mana yang memiliki pengaruh terbesar pada perilaku model?
Anda dapat menggunakan penjelasan untuk mengaudit dan memenuhi persyaratan peraturan, membangun kepercayaan pada model dan mendukung pengambilan keputusan manusia, serta men-debug dan meningkatkan kinerja model.
Kebutuhan untuk memenuhi tuntutan pemahaman manusia tentang sifat dan hasil inferensi ML adalah kunci untuk jenis penjelasan yang dibutuhkan. Penelitian dari filsafat dan disiplin ilmu kognitif telah menunjukkan bahwa orang peduli terutama tentang penjelasan kontras, atau penjelasan mengapa suatu peristiwa X terjadi alih-alih beberapa peristiwa lain Y yang tidak terjadi. Di sini, X bisa menjadi peristiwa tak terduga atau mengejutkan yang terjadi dan Y sesuai dengan harapan berdasarkan model mental mereka yang ada yang disebut sebagai *baseline*. Perhatikan bahwa untuk peristiwa X yang sama, orang yang berbeda mungkin mencari penjelasan yang berbeda tergantung pada sudut pandang mereka atau model mental Y. Dalam konteks AI yang dapat dijelaskan, Anda dapat menganggap X sebagai contoh yang sedang dijelaskan dan Y sebagai garis dasar yang biasanya dipilih untuk mewakili contoh yang tidak informatif atau rata-rata dalam kumpulan data. Terkadang, misalnya dalam kasus pemodelan gambar dari ML, baseline mungkin implisit, di mana gambar yang pikselnya memiliki warna yang sama dapat berfungsi sebagai garis dasar.
## Contoh Notebook
Amazon SageMaker Clarify menyediakan contoh notebook berikut untuk penjelasan model:
+ [Amazon SageMaker Clarify Processing](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-clarify/index.html#sagemaker-clarify-processing) — Gunakan SageMaker Clarify untuk membuat pekerjaan pemrosesan untuk mendeteksi bias dan menjelaskan prediksi model dengan atribusi fitur. Contohnya termasuk menggunakan format data CSV dan JSON Lines, membawa wadah Anda sendiri, dan menjalankan pekerjaan pemrosesan dengan Spark.
+ [Menjelaskan Klasifikasi Gambar dengan SageMaker Clarify](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-clarify/computer_vision/image_classification/explainability_image_classification.ipynb) — SageMaker Clarify memberi Anda wawasan tentang bagaimana model visi komputer Anda mengklasifikasikan gambar.
+ [Menjelaskan model deteksi objek dengan SageMaker Clarify](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-clarify/computer_vision/object_detection/object_detection_clarify.ipynb) — SageMaker Clarify memberi Anda wawasan tentang cara model visi komputer Anda mendeteksi objek.
Notebook ini telah diverifikasi untuk berjalan di Amazon SageMaker Studio saja. Jika Anda memerlukan petunjuk tentang cara membuka buku catatan di Amazon SageMaker Studio, lihat[Membuat atau Membuka Notebook Amazon SageMaker Studio Classic](notebooks-create-open.md). Jika Anda diminta untuk memilih kernel, pilih **Python 3 (Ilmu Data)**.
**Topics**
+ [Contoh Notebook](#clarify-model-explainability-sample-notebooks)
+ [Atribusi Fitur yang Menggunakan Nilai Shapley](clarify-shapley-values.md)
+ [Nilai Shapley Asimetris](clarify-feature-attribute-shap-asymm.md)
+ [Garis Dasar SHAP untuk Penjelasan](clarify-feature-attribute-shap-baselines.md)
# Atribusi Fitur yang Menggunakan Nilai Shapley
SageMaker Clarify menyediakan atribusi fitur berdasarkan konsep nilai [Shapley](https://en.wikipedia.org/wiki/Shapley_value). Anda dapat menggunakan nilai Shapley untuk menentukan kontribusi yang dibuat setiap fitur untuk memodelkan prediksi. Atribusi ini dapat disediakan untuk prediksi spesifik dan pada tingkat global untuk model secara keseluruhan. Misalnya, jika Anda menggunakan model ML untuk penerimaan perguruan tinggi, penjelasannya dapat membantu menentukan apakah IPK atau skor SAT adalah fitur yang paling bertanggung jawab atas prediksi model, dan kemudian Anda dapat menentukan seberapa bertanggung jawab setiap fitur untuk menentukan keputusan penerimaan tentang siswa tertentu.
SageMaker Clarify telah mengambil konsep nilai-nilai Shapley dari teori permainan dan menerapkannya dalam konteks pembelajaran mesin. Nilai Shapley menyediakan cara untuk mengukur kontribusi setiap pemain ke permainan, dan karenanya sarana untuk mendistribusikan total keuntungan yang dihasilkan oleh permainan kepada para pemainnya berdasarkan kontribusi mereka. Dalam konteks pembelajaran mesin ini, SageMaker Clarify memperlakukan prediksi model pada contoh tertentu sebagai *permainan* dan fitur yang termasuk dalam model sebagai *pemain*. Untuk perkiraan pertama, Anda mungkin tergoda untuk menentukan kontribusi atau efek marjinal dari setiap fitur dengan mengukur hasil dari menjatuhkan fitur itu dari model atau **menjatuhkan** semua fitur lain dari model. Namun, pendekatan ini tidak memperhitungkan bahwa fitur yang termasuk dalam model seringkali tidak independen satu sama lain. Misalnya, jika dua fitur sangat berkorelasi, menjatuhkan salah satu fitur mungkin tidak mengubah prediksi model secara signifikan.
Untuk mengatasi dependensi potensial ini, nilai Shapley mensyaratkan bahwa hasil dari setiap kemungkinan kombinasi (atau koalisi) fitur harus dipertimbangkan untuk menentukan pentingnya setiap fitur. Diberikan fitur *d*, ada 2 d kemungkinan kombinasi fitur seperti itu, masing-masing sesuai dengan model potensial. Untuk menentukan atribusi untuk fitur tertentu *f*, pertimbangkan kontribusi marjinal dari memasukkan *f* dalam semua kombinasi fitur (dan model terkait) yang tidak mengandung *f*, dan ambil rata-rata. Dapat ditunjukkan bahwa nilai Shapley adalah cara unik untuk menetapkan kontribusi atau pentingnya setiap fitur yang memenuhi properti tertentu yang diinginkan. Secara khusus, jumlah nilai Shapley dari setiap fitur sesuai dengan perbedaan antara prediksi model dan model tiruan tanpa fitur. Namun, bahkan untuk nilai *d* yang wajar, katakanlah 50 fitur, secara komputasi penghalang dan tidak praktis untuk melatih 2 d model yang mungkin. Akibatnya, SageMaker Clarify perlu menggunakan berbagai teknik aproksimasi. Untuk tujuan ini, SageMaker Clarify menggunakan Shapley Additive Explanations (SHAP), yang menggabungkan perkiraan tersebut dan merancang implementasi algoritma Kernel SHAP yang dapat diskalakan dan efisien melalui pengoptimalan tambahan.
Untuk informasi tambahan tentang nilai Shapley, lihat [Pendekatan Terpadu untuk Menafsirkan](https://papers.nips.cc/paper/2017/file/8a20a8621978632d76c43dfd28b67767-Paper.pdf) Prediksi Model.
# Nilai Shapley Asimetris
Solusi penjelasan model peramalan deret waktu SageMaker Clarify adalah metode atribusi fitur yang berakar pada [teori permainan kooperatif](https://en.wikipedia.org/wiki/Cooperative_game_theory), serupa dengan semangat SHAP. Secara khusus, Clarify menggunakan [nilai kelompok urutan acak](http://www.library.fa.ru/files/Roth2.pdf#page=121), juga dikenal sebagai [nilai Shapley asimetris](https://proceedings.neurips.cc/paper/2020/file/0d770c496aa3da6d2c3f2bd19e7b9d6b-Paper.pdf) dalam pembelajaran mesin dan penjelasan.
## Latar Belakang
*Tujuannya adalah untuk menghitung atribusi untuk fitur input ke model peramalan tertentu f.* Model peramalan mengambil masukan berikut:
+ Deret waktu lalu *(target TS)*. *Misalnya, ini bisa melewati penumpang kereta harian di rute Paris-Berlin, dilambangkan dengan x. t*
+ (Opsional) Deret waktu kovariat. Misalnya, ini bisa berupa perayaan dan data cuaca, dilambangkan dengan z *∈ t* R S. Saat digunakan, TS kovariat hanya tersedia untuk langkah-langkah masa lalu atau juga untuk masa depan (termasuk dalam kalender perayaan).
+ (Opsional) Kovariat statis, seperti kualitas layanan (seperti kelas 1 atau 2), dilambangkan dengan u *∈* R E.
Kovariat statis, kovariat dinamis, atau keduanya dapat dihilangkan, tergantung pada skenario aplikasi spesifik. Diberikan prediksi horizon K ≥ 0 (misalnya K = 30 hari) prediksi model dapat dicirikan dengan rumus: *f (x[1:T], z[1:T\$1K], u) = x*. [T\$11:T \$1K\$11]
Diagram berikut menunjukkan struktur ketergantungan untuk model peramalan tipikal. Prediksi pada waktu *t\$11* tergantung pada tiga jenis input yang disebutkan sebelumnya.
![\[Struktur ketergantungan untuk model peramalan tipikal.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/clarify/clarify-forecast-dependency.png)
## Metode
Penjelasan dihitung dengan menanyakan model deret waktu *f* pada serangkaian titik yang diturunkan oleh input asli. Mengikuti konstruksi teoritis permainan, Klarifikasi rata-rata perbedaan dalam prediksi yang dipimpin oleh mengaburkan (yaitu, pengaturan ke nilai dasar) bagian dari input secara iteratif. Struktur temporal dapat dinavigasi dalam urutan kronologis atau anti-kronologis atau keduanya. Penjelasan kronologis dibangun dengan menambahkan informasi secara berulang dari langkah pertama kali, sementara anti-kronologis dari langkah terakhir. Mode terakhir mungkin lebih tepat dengan adanya bias kebaruan, seperti saat memperkirakan harga saham. Salah satu properti penting dari penjelasan yang dihitung adalah bahwa mereka menjumlahkan output model asli jika model memberikan output deterministik.
## Atribusi yang dihasilkan
Atribusi yang dihasilkan adalah skor yang menandai kontribusi individu dari langkah waktu tertentu atau fitur masukan menuju perkiraan akhir pada setiap langkah waktu yang diperkirakan. Clarify menawarkan dua perincian berikut untuk penjelasan:
+ Penjelasan waktu tidak mahal dan memberikan informasi tentang langkah-langkah waktu tertentu saja, seperti seberapa banyak informasi hari ke-19 di masa lalu berkontribusi pada peramalan hari pertama di masa depan. Atribusi ini tidak menjelaskan kovariat statis individual dan penjelasan agregat dari deret waktu target dan kovariat. *Atribusi adalah matriks *A* di mana masing-masing *A tk* adalah atribusi langkah waktu *t* menuju peramalan langkah waktu T\$1k.* *Perhatikan bahwa jika model menerima kovariat future, *t* bisa lebih besar dari T.*
+ Penjelasan berbutir halus lebih intensif secara komputasi dan memberikan rincian lengkap dari semua atribusi variabel input.
**catatan**
Penjelasan berbutir halus hanya mendukung urutan kronologis.
Atribusi yang dihasilkan adalah triplet yang terdiri dari yang berikut:
+ *Matriks *A x* ∈ R T×K terkait dengan deret waktu masukan, di mana *A tk x* adalah atribusi *x t* terhadap langkah peramalan T\$1k*
+ *Tensor *A z* ∈ *R T\$1K×S×K* terkait dengan deret waktu kovariat, di mana *A tsk z adalah atribusi *z ts** (yaitu sth kovariat TS) terhadap langkah peramalan T\$1k*
+ *Matriks *A u* ∈ R E×K terkait dengan kovariat statis, di mana *A ek u adalah atribusi *u e** (kovariat statis eth) terhadap langkah peramalan T\$1k*
Terlepas dari granularitasnya, penjelasannya juga berisi vektor offset *B ∈* *R K* yang mewakili “perilaku dasar” model ketika semua data dikaburkan.
# Garis Dasar SHAP untuk Penjelasan
Penjelasan biasanya kontrastif (yaitu, mereka menjelaskan penyimpangan dari garis dasar). Akibatnya, untuk prediksi model yang sama, Anda dapat mengharapkan untuk mendapatkan penjelasan yang berbeda sehubungan dengan garis dasar yang berbeda. Oleh karena itu, pilihan baseline Anda sangat penting. *Dalam konteks ML, baseline sesuai dengan contoh hipotetis yang dapat berupa *tidak* informatif atau informatif.* Selama perhitungan nilai Shapley, SageMaker Clarify menghasilkan beberapa instance baru antara baseline dan instance yang diberikan, di mana tidak adanya fitur, dimodelkan dengan menetapkan nilai fitur ke nilai baseline dan keberadaan fitur dimodelkan dengan menetapkan nilai fitur ke nilai instance yang diberikan. Dengan demikian, tidak adanya semua fitur sesuai dengan baseline dan keberadaan semua fitur sesuai dengan contoh yang diberikan.
Bagaimana Anda bisa memilih baseline yang baik? Seringkali diinginkan untuk memilih garis dasar dengan konten informasi yang sangat rendah. Misalnya, Anda dapat membuat instance rata-rata dari kumpulan data pelatihan dengan mengambil median atau rata-rata untuk fitur numerik dan mode untuk fitur kategoris. Untuk contoh penerimaan perguruan tinggi, Anda mungkin tertarik untuk menjelaskan mengapa pelamar tertentu diterima dibandingkan dengan penerimaan dasar berdasarkan pelamar rata-rata. Jika tidak disediakan, baseline dihitung secara otomatis dengan SageMaker Clarify menggunakan K-mean atau K-prototipe dalam dataset input.
Atau, Anda dapat memilih untuk menghasilkan penjelasan sehubungan dengan baseline informatif. Untuk skenario penerimaan perguruan tinggi, Anda mungkin ingin menjelaskan mengapa pelamar tertentu ditolak jika dibandingkan dengan pelamar lain dari latar belakang demografis yang sama. Dalam hal ini, Anda dapat memilih garis dasar yang mewakili pelamar yang diminati, yaitu mereka yang memiliki latar belakang demografis yang sama. Dengan demikian, Anda dapat menggunakan garis dasar informatif untuk memusatkan analisis pada aspek spesifik dari prediksi model tertentu. Anda dapat mengisolasi fitur untuk penilaian dengan menyetel atribut demografis dan fitur lain yang tidak dapat ditindaklanjuti dengan nilai yang sama seperti pada instance yang diberikan.
# SageMaker Klarifikasi penjelasan dengan SageMaker AI Autopilot
Autopilot menggunakan alat yang disediakan oleh Amazon SageMaker Clarify untuk membantu memberikan wawasan tentang bagaimana model pembelajaran mesin (ML) membuat prediksi. Alat-alat ini dapat membantu insinyur, manajer produk, dan pemangku kepentingan internal lainnya memahami karakteristik model. Untuk mempercayai dan menafsirkan keputusan yang dibuat berdasarkan prediksi model, baik konsumen maupun regulator mengandalkan transparansi dalam pembelajaran mesin secara berurutan.
Fungsionalitas penjelasan Autopilot menggunakan pendekatan atribusi fitur model-agnostik. Pendekatan ini menentukan kontribusi fitur atau input individu terhadap output model, memberikan wawasan tentang relevansi fitur yang berbeda. Anda dapat menggunakannya untuk memahami mengapa model membuat prediksi setelah pelatihan, atau menggunakannya untuk memberikan penjelasan per contoh selama inferensi. Implementasinya mencakup implementasi [SHAP (Shapley Additive Explanations](https://papers.nips.cc/paper/2017/file/8a20a8621978632d76c43dfd28b67767-Paper.pdf)) yang dapat diskalakan. Implementasi ini didasarkan pada konsep nilai Shapley dari teori permainan kooperatif, yang memberikan setiap fitur nilai penting untuk prediksi tertentu.
Anda dapat menggunakan penjelasan SHAP untuk hal-hal berikut: mengaudit dan memenuhi persyaratan peraturan, membangun kepercayaan pada model, mendukung pengambilan keputusan manusia, atau men-debug dan meningkatkan kinerja model.
Untuk informasi tambahan tentang nilai dan garis dasar Shapley, lihat Garis Dasar [SHAP](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-feature-attribute-shap-baselines.html) untuk Keterjelasan.
Untuk panduan dokumentasi Amazon SageMaker Clarify, lihat [Panduan untuk SageMaker Klarifikasi Dokumentasi](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html#clarify-fairness-and-explainability-toc).