Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# 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\_template 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 {'predictions [\*] .mean [:2] '}}, 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.