Tutorial DeepChecks: Mengotomatiskan Pengujian Machine Learning

Dalam tutorial ini, kita akan mempelajari tentang DeepChecks dan cara menggunakannya untuk melakukan validasi data dan pengujian machine learning. Kita juga akan menggunakan GitHub Actions untuk mengotomatiskan pengujian model dan menyimpan hasilnya sebagai artefak. 

Seiring berjalannya pembahasan, kita akan mempelajari tentang pengujian machine learning dan DeepChecks, menjalankan suite integritas data DeepChecks, serta menghasilkan laporan komprehensif. Kita juga akan membuat laporan pengujian machine learning dengan menjalankan suite evaluasi model, mempelajari cara menjalankan satu pengujian alih-alih seluruh suite, mengotomatiskan alur kerja pengujian menggunakan GitHub Actions, dan menyimpan laporan pengujian machine learning sebagai GitHub Artifact. 

Gambar oleh Penulis

Apa itu Pengujian Machine Learning?

Pengujian machine learning adalah proses krusial yang melibatkan evaluasi dan validasi kinerja model machine learning untuk memastikan keadilan, akurasi, dan ketahanannya. Ini tidak hanya soal akurasi dan performa model. Kita juga harus melihat bias model, false positive, false negative, berbagai metrik kinerja, throughput model, dan keselarasan model dengan etika AI. 

Proses pengujian mencakup berbagai jenis penilaian seperti validasi data, cross-validation, F1-score, confusion matrix, prediction drift, data drift, dan uji ketahanan, yang masing-masing dirancang untuk memverifikasi aspek berbeda dari kinerja dan keandalan model. 

Kita juga membagi dataset menjadi tiga bagian agar dapat mengevaluasi model selama proses pelatihan dan setelah proses pelatihan pada dataset yang belum pernah dilihat. 

Pengujian machine learning adalah bagian penting dari aplikasi AI, dan mengotomatiskannya bersama dengan pelatihan model akan memberikan sistem AI yang andal dan bermanfaat bagi manusia.

Jika Anda baru di bidang machine learning dan ingin mempelajari dasar-dasarnya, ikuti Fundamental Machine Learning dengan skill track Python. Kursus ini akan mengajarkan dasar-dasar machine learning dengan Python, dimulai dari supervised learning menggunakan pustaka scikit-learn.

Mulai dengan DeepChecks

DeepChecks adalah paket Python open-source yang dirancang untuk memfasilitasi pengujian dan validasi komprehensif terhadap model dan data machine learning. Paket ini menyediakan beragam pemeriksaan bawaan untuk mengidentifikasi masalah terkait kinerja model, distribusi data, integritas data, dan lainnya. DeepChecks juga mencakup fungsionalitas validasi berkelanjutan, memastikan model tetap andal dan efektif saat diterapkan dan digunakan dalam skenario dunia nyata.

Kita akan mulai dengan memasang paket Python menggunakan perintah pip.

%pip install deepchecks --upgrade -qDidukung oleh

Memuat dataset

Untuk tutorial ini, kita menggunakan Data Pinjaman dari dataset DataCamp. Dataset ini terdiri dari 9578 baris dan memuat informasi tentang struktur pinjaman, peminjam, dan apakah pinjaman dilunasi sepenuhnya.

Muat file CSV menggunakan Pandas dan tampilkan 5 baris teratas.

import pandas as pd
loan_data = pd.read_csv("loan_data.csv")
loan_data.head()Didukung oleh

Menyiapkan dataset

Buat dataset DeepChecks menggunakan dataset pinjaman, nama kolom label, dan nama fitur kategorikal.

from sklearn.model_selection import train_test_split
from deepchecks.tabular import Dataset

label_col = 'not.fully.paid'

deep_loan_data = Dataset(loan_data, label=label_col, cat_features=["purpose"])Didukung oleh

Menjalankan suite integritas data DeepChecks

Kita akan menggunakan suite integritas data untuk data tabular. Suite ini akan menjalankan semua pengujian secara otomatis dan menghasilkan laporan interaktif dengan hasilnya. 

Untuk melakukannya, kita akan mengimpor suite integritas data, memulainya, lalu menjalankan suite dengan memberikan data pinjaman DeepChecks. Terakhir, kita akan menampilkan hasilnya.

from deepchecks.tabular.suites import data_integrity

integ_suite = data_integrity()
suite_result = integ_suite.run(deep_loan_data)
suite_result.show()Didukung oleh

Catatan: Kami menggunakan DataLab sebagai lingkungan pengembangan. Penggunaan ipywidgets dinonaktifkan, sehingga hasil tidak dapat ditampilkan. Sebagai gantinya, kita akan menggunakan fungsi 'show_in_iframe' untuk menampilkan hasil sebagai iframe. Hasilnya akan sama pada setiap level.

suite_result.show_in_iframe()Didukung oleh

Laporan integritas data kami mencakup hasil pengujian pada:

• Korelasi Fitur-Label
• Korelasi Fitur-Fitur
• Nilai Tunggal dalam Kolom
• Karakter Khusus
• Null Campuran
• Tipe Data Campuran
• Ketidakcocokan String
• Duplikasi Data
• Panjang String di Luar Batas
• Label yang Bertentangan
• Deteksi Sampel Pencilan

Hasil uji Integritas Data di Jupyter Notebook. 

Anda bahkan dapat menyimpan hasil sebagai file HTML dan membagikannya dengan rekan kerja. 

suite_result.save_as_html()Didukung oleh

'output.html'Didukung oleh

Menjalankan satu pengujian

Menjalankan seluruh suite pada dataset besar tidak efisien karena akan memakan waktu lama untuk menghasilkan hasil. Sebagai gantinya, Anda dapat menjalankan beberapa pengujian individual yang relevan dengan data Anda dan membuat laporan sendiri.

Untuk menjalankan satu pengujian, impor tabular checks, inisialisasi check, dan jalankan dengan data Pinjaman DeepCheck. Setelah itu, tampilkan nilai alih-alih menghasilkan laporan interaktif menggunakan fungsi results.value.

from deepchecks.tabular.checks import IsSingleValue, DataDuplicates

result = IsSingleValue().run(deep_loan_data)
result.valueDidukung oleh

Seperti yang terlihat, ini menampilkan jumlah nilai unik yang ada di setiap kolom. 

{'credit.policy': 2,
 'purpose': 7,
 'int.rate': 249,
 'installment': 4788,
 'log.annual.inc': 1987,
 'dti': 2529,
 'fico': 44,
 'days.with.cr.line': 2687,
 'revol.bal': 7869,
 'revol.util': 1035,
 'inq.last.6mths': 28,
 'delinq.2yrs': 11,
 'pub.rec': 6,
 'not.fully.paid': 2}Didukung oleh

Mari coba memeriksa sampel duplikat dalam data kita. 

result = DataDuplicates().run(deep_loan_data)
result.valueDidukung oleh

Kita tidak memiliki duplikasi dalam dataset. 

0.0Didukung oleh

Pengujian Machine Learning dengan DeepChecks

Pada bagian ini, kita akan meng-ensemble beberapa model dan melatihnya pada dataset pinjaman yang telah diproses. Kemudian, untuk menghasilkan laporan pengujian model, kita akan menjalankan suite evaluasi model pada dataset pelatihan dan pengujian. 

Pemrosesan data dan pelatihan model

1. Impor fungsi penting dari pustaka Scikit-learn. 
2. Bagi dataset menjadi set latih dan uji. 
3. Ubah kolom kategorikal 'purpose' menjadi numerik menggunakan label encoder.
4. Definisikan model LogisticRegression, RandomForestClassifier, dan GaussianNB. 
5. Ensemble model menggunakan voting classifier. 
6. Latih model ensemble pada set pelatihan. 

from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import VotingClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.preprocessing import LabelEncoder

# Train test split
df_train, df_test = train_test_split(loan_data, stratify=loan_data[label_col], random_state=0)

# Encode the 'purpose' column
label_encoder = LabelEncoder()
df_train['purpose'] = label_encoder.fit_transform(df_train['purpose'])
df_test['purpose'] = label_encoder.fit_transform(df_test['purpose'])

# Define models
model_1 = LogisticRegression(random_state=1, max_iter=10000)
model_2 = RandomForestClassifier(n_estimators=50, random_state=1)
model_3 = GaussianNB()

# Create the VotingClassifier
clf_model = VotingClassifier(
    estimators=[('lr', model_1), ('rf', model_2), ('svc', model_3)],
    voting='soft'
)

# Train the model
clf_model.fit(df_train.drop(label_col, axis=1), df_train[label_col])Didukung oleh

Menjalankan suite evaluasi model

Kita akan menjalankan suite evaluasi model DeepChecks untuk mengevaluasi kinerja model. 

7. Ubah set latih dan uji menjadi dataset DeepCheck. 
8. Inisiasi evaluasi model dan jalankan menggunakan set latih, uji, dan model. 
9. Tampilkan hasil dalam iframe. 

from deepchecks.tabular.suites import model_evaluation

deep_train = Dataset(df_train, label=label_col, cat_features=[])
deep_test =  Dataset(df_test,  label=label_col, cat_features=[])

evaluation_suite = model_evaluation()
suite_result = evaluation_suite.run(deep_train, deep_test, clf_model)
suite_result.show_in_iframe()Didukung oleh

Laporan evaluasi model kami mencakup hasil pengujian pada:

• Laporan ROC
• Kinerja Segmen Lemah
• Fitur yang Tidak Digunakan
• Kinerja Latih-Uji
• Prediction Drift
• Perbandingan Model Sederhana
• Waktu Inferensi Model
• Laporan Confusion Matrix
• Dan lainnya

10. Untuk melihat hasil dalam format JSON, gunakan fungsi to_json(). 

suite_result.to_json()Didukung oleh

Menjalankan Satu Pengujian

Sama seperti validasi data, Anda dapat menjalankan satu pengujian machine learning. Dalam kasus kita, kita akan menjalankan label drift pada pembagian latih dan uji untuk memeriksa apakah label berubah seiring waktu. 

from deepchecks.tabular.checks import LabelDrift
check = LabelDrift()
result = check.run(deep_train, deep_test)
result.valueDidukung oleh

Tidak ada drift yang terdeteksi dalam data.

{'Drift score': 0.0, 'Method': "Cramer's V"}Didukung oleh

Jika Anda mengalami kesulitan menjalankan suite validasi data dan evaluasi model, silakan lihat workspace DataLab di Pengujian Machine Learning dengan DeepChecks.

Jika Anda tertarik pada pengujian machine learning secara "manual", ikuti tutorial Eksperimen Machine Learning untuk mempelajari cara menyusun, mencatat, dan menganalisis eksperimen machine learning Anda menggunakan Weights & Biases.

Mengotomatiskan Pengujian Machine Learning menggunakan GitHub Actions dan DeepChecks

Mari kita otomatisasi fase validasi data, pelatihan model, dan evaluasi model dengan GitHub Actions dan simpan hasilnya sebagai file zip. 

Mengotomatiskan pengujian machine learning adalah bagian integral dari pipeline MLOps. Pelajari lebih lanjut dengan mengikuti skill track MLOps Fundamentals. Dalam rangkaian kursus ini, Anda akan mempelajari prinsip-prinsip dasar menempatkan model machine learning ke produksi dan memantau mereka untuk memberikan nilai bisnis.

Penyiapan

1. Masuk ke akun GitHub dan buat repositori baru dengan semua informasi yang diperlukan. 

2. Kloning repositori di sistem lokal.
3. Ubah direktori ke repositori. 
4. Buat folder baru, “data,” dan pindahkan file CSV data pinjaman dari folder "Downloads" ke folder repositori. 
5. Buat validasi data dalam Python dan luncurkan VSCode (lingkungan pengembangan terintegrasi). 

$ cd C:\Repository\GitHub\
$ git clone https://github.com/kingabzpro/Automating-Machine-Learning-Testing.git

$ cd .\Automating-Machine-Learning-Testing\
$ mkdir data
$ mv -v ".Downloads\loan_data.csv" ".\Automating-Machine-Learning-Testing\data"
$ code -r data_validation.pyDidukung oleh

Berkas validasi data

6. Dalam berkas validasi data, Anda akan memuat file CSV, mengubahnya menjadi dataset DeepChecks, memulai suite integrasi data, dan menjalankannya pada dataset pinjaman. 
7. Buat folder baru “results” dan simpan sebagai file HTML. 

import pandas as pd
from deepchecks.tabular import Dataset
from deepchecks.tabular.suites import data_integrity

# Load the loan data from a CSV file
loan_data = pd.read_csv("data/loan_data.csv")

# Define the label column
label_col = "not.fully.paid"

# Create a Deepchecks Dataset object with the loan data
deep_loan_data = Dataset(loan_data, label=label_col, cat_features=["purpose"])

# Initialize the data integrity suite
integ_suite = data_integrity()

# Run the data integrity suite on the dataset
suite_result = integ_suite.run(deep_loan_data)

# Save the results of the data integrity suite as an HTML file
suite_result.save_as_html("results/data_validation.html")Didukung oleh

Berkas pengujian model

8. Buat berkas Python untuk validasi data yang mencakup pemrosesan data, pembuatan model, pelatihan, dan evaluasi. Berkas tersebut juga harus mencakup pengubahan dataset menjadi dataset DeepChecks, menjalankan suite evaluasi model, dan menyimpannya sebagai file HTML di folder "results".

$ code -r train_validation.pyDidukung oleh

import pandas as pd
from sklearn.ensemble import RandomForestClassifier, VotingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
from sklearn.preprocessing import LabelEncoder, StandardScaler
from deepchecks.tabular import Dataset
from deepchecks.tabular.suites import model_evaluation

# Load the loan data from a CSV file
loan_data = pd.read_csv("data/loan_data.csv")

# Define the label column
label_col = "not.fully.paid"

# Train test split
df_train, df_test = train_test_split(
    loan_data, stratify=loan_data[label_col], random_state=0
)

# Encode the 'purpose' column
label_encoder = LabelEncoder()
df_train["purpose"] = label_encoder.fit_transform(df_train["purpose"])
df_test["purpose"] = label_encoder.transform(df_test["purpose"])

# Standardize the features
scaler = StandardScaler()
df_train[df_train.columns.difference([label_col])] = scaler.fit_transform(df_train[df_train.columns.difference([label_col])])
df_test[df_test.columns.difference([label_col])] = scaler.transform(df_test[df_test.columns.difference([label_col])])

# Define models
model_1 = LogisticRegression(random_state=1, max_iter=10000)
model_2 = RandomForestClassifier(n_estimators=50, random_state=1)
model_3 = GaussianNB()

# Create the VotingClassifier
clf_model = VotingClassifier(
    estimators=[("lr", model_1), ("rf", model_2), ("gnb", model_3)], voting="soft"
)

# Train the model
clf_model.fit(df_train.drop(label_col, axis=1), df_train[label_col])

# Calculate the accuracy score using the .score function
accuracy = clf_model.score(df_test.drop(label_col, axis=1), df_test[label_col])

# Print the accuracy score
print(f"Accuracy: {accuracy:.2f}")

# Create Deepchecks datasets
deep_train = Dataset(df_train, label=label_col, cat_features=["purpose"])
deep_test = Dataset(df_test, label=label_col, cat_features=["purpose"])

# Run the evaluation suite
evaluation_suite = model_evaluation()
suite_result = evaluation_suite.run(deep_train, deep_test, clf_model)

# Save the results as HTML
suite_result.save_as_html("results/model_validation.html")Didukung oleh

Menggunakan GitHub Actions

Jika Anda baru mengenal GitHub Actions, harap selesaikan tutorial "GitHub Actions dan MakeFile: Pengantar Praktis" sebelum memulai proses otomatisasi. Tutorial ini akan memberikan pemahaman mendetail tentang cara kerja GitHub Actions dengan contoh kode.

9. Untuk menginisiasi GitHub Actions, Anda harus stage dan commit perubahan serta mendorongnya ke repositori GitHub jarak jauh. 

$ git add .
$ git commit -m "Data and Validation files"  
$ git pushDidukung oleh

10. Buka repositori GitHub dan klik tab “Actions” lalu klik teks biru “set up a workflow yourself”. 

11. Kita akan diarahkan ke berkas workflow main.yml. Silakan salin dan tempel kode berikut. Kode di bawah ini akan terlebih dahulu menyiapkan lingkungan dan memasang paket DeepChecks. Setelah itu, akan membuat folder, menjalankan validasi data dan evaluasi model, serta menyimpan hasil sebagai GitHub Artifact.

name: Model Training and Validation

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout Repository
        uses: actions/checkout@v4

      - name: Set up Python 3.10
        uses: actions/setup-python@v5
        with:
          python-version: '3.10'

      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install deepchecks
          
      - name: Create a folder
        run: |
          mkdir -p results
          
      - name: Validate Data
        run: |
          python data_validation.py
      - name: Validate Model Performance
        run: |
          python train_validation.py
      - name: Archive Deepchecks Results
        uses: actions/upload-artifact@v4
        if: always()
        with:
          name: deepchecks results
          path: results/*_validation.htmlDidukung oleh

12. Commit perubahan dengan pesan. 

Dengan melakukan commit perubahan ke branch utama, workflow run akan dimulai. Untuk melihat log run, buka tab "Actions" dan klik workflow run saat ini yang terkait dengan pesan commit.

13. Saat workflow run selesai, silakan gulir ke bawah dan unduh file zip di bagian “Artifacts”.

14. Buka file zip secara lokal dan lihat hasil validasi data dan model. 

Silakan lihat repositori GitHub kingabzpro/Automating-Machine-Learning-Testing sebagai panduan. Repositori ini berisi data, kode Python, berkas workflow, dan berkas lain yang diperlukan untuk menjalankan pengujian yang sepenuhnya otomatis. 

Mengotomatiskan seluruh pipeline machine learning memerlukan pengetahuan tentang berbagai proses dan alat. Untuk mempelajarinya, pertimbangkan untuk mengikuti kursus MLOps Deployment and Lifecycle. Kursus ini membahas kerangka kerja MLOps modern, berfokus pada siklus hidup dan deployment model machine learning.

Kesimpulan

Dengan mengotomatiskan proses pengujian, pengembang dapat dengan cepat dan efisien memvalidasi akurasi dan ketahanan model terhadap dataset yang besar dan kompleks. Pengujian otomatis membantu mengidentifikasi masalah sejak dini, seperti ketidakkonsistenan data, data drift, dan bias model, yang mungkin tidak terlihat melalui pengujian manual. Ini menghemat waktu dan meningkatkan kemampuan model untuk memberikan prediksi yang adil dan akurat.

Dalam tutorial ini, kita mempelajari tentang pengujian machine learning dan cara menggunakan DeepChecks untuk validasi data serta pengujian machine learning. Kita juga mengotomatiskan pengujian data dan model serta menyimpan hasilnya sebagai artefak menggunakan GitHub Actions. 

Jika Anda menyukai tutorial ini dan tertarik memulai karier di bidang machine learning, pertimbangkan untuk mendaftar jalur karier Machine Learning Scientist with Python. Selesaikan semua kursus dalam 3 bulan untuk mendapatkan keterampilan yang Anda perlukan untuk bekerja sebagai ilmuwan machine learning.