Logika Suara dan Model AI Monotonik

AI dengan cepat menjadi aset yang luar biasa, setelah mencapai tingkat kinerja manusia super dalam domain seperti pengenalan gambar, Go, dan bahkan poker. Banyak yang bersemangat tentang masa depan AI dan kemanusiaan. Pada saat yang sama, ada anggapan umum bahwa AI memang menderita satu kelemahan yang mengganggu: AI dalam kondisi saat ini bisa jadi tidak dapat diprediksi dan tidak dapat diandalkan.

Contoh klasiknya adalah Jeopardy! Tantangan IBM , di mana Watson, IBM AI, membersihkan papan dengan mudah, hanya untuk melewatkan "Jeopardy Akhir!" pertanyaan, yang termasuk dalam kategori US Cities : “Bandara terbesarnya dinamai untuk pahlawan Perang Dunia II; terbesar kedua untuk pertempuran Perang Dunia II.” Watson menjawab, “Apa itu Toronto?????”—tanda tanya tambahan (dan taruhan rendah) menunjukkan keraguannya.

Jadi, meskipun AI memiliki kapasitas untuk kinerja seperti dongeng untuk jangka waktu yang lama—berbulan-bulan, bertahun-tahun, bahkan berpuluh -puluh tahun—selalu ada kemungkinan yang mengganggu bahwa tiba-tiba, itu akan secara misterius melakukan kesalahan.

Yang paling mengkhawatirkan bagi kita manusia bukanlah bahwa AI akan membuat kesalahan, tetapi seberapa "tidak logis" kesalahan itu. Dalam kasus Watson, seseorang yang tidak tahu jawaban atas pertanyaan tersebut akan "secara logis" mencoba untuk setidaknya menebak kota besar AS. Saya percaya bahwa ini adalah salah satu alasan utama kami belum memiliki adopsi publik mobil self-driving: Bahkan jika mobil self-driving mungkin secara statistik lebih aman, kami khawatir AI yang mendasarinya mungkin secara tak terduga melakukan kesalahan dalam arti yang mirip dengan Watson , tetapi dengan dampak yang jauh lebih serius.

Ini membuat saya bertanya-tanya, dapatkah model AI yang tepat memperbaiki masalah ini? Mungkinkah AI yang tepat memiliki kemampuan untuk membuat keputusan yang tepat di saat-saat kritis, meskipun tidak memiliki semua jawaban? AI semacam itu akan dapat mengubah arah teknologi dan memungkinkan kita mendapatkan manfaat AI yang seperti dongeng…

Saya percaya jawaban atas pertanyaan-pertanyaan ini adalah ya. Saya percaya bahwa kesalahan seperti yang dilakukan Watson dapat dihindari dengan penggunaan model yang ditingkatkan dan dibatasi secara logis, prototipe awal yang disebut model pembelajaran mesin monoton . Tanpa merinci dulu, dengan model AI monoton yang tepat:

• Mobil self-driving akan lebih aman, karena pendeteksian sinyal manusia dalam jumlah terkecil pun akan selalu cukup untuk mengaktifkan protokol keselamatan bahkan di hadapan sejumlah besar sinyal lain.
• Sistem pembelajaran mesin (ML) akan lebih kuat terhadap serangan musuh dan situasi tak terduga.
• Performa ML akan lebih logis dan dapat dipahami secara manusiawi.

Saya yakin kita sedang bergerak dari era pertumbuhan besar dalam kekuatan komputasi dan algoritme AI ke era kemahiran, efektivitas, dan pemahaman dalam AI, dan model pembelajaran mesin monoton adalah langkah pertama dalam perjalanan yang mengasyikkan ini. Model monoton membuat AI lebih “logis”.

Catatan editor: Pembaca yang ingin mengambil langkah pertama mereka sendiri dalam memahami dasar-dasar ML dianjurkan untuk membaca artikel pengantar kami tentang ML.

Teori Model AI Monotonik

Jadi apa itu model monoton? Secara sederhana, model monotonik adalah model ML yang memiliki beberapa kumpulan fitur (fitur monoton ) yang peningkatannya selalu mengarahkan model untuk meningkatkan outputnya.

Dalam kehidupan nyata, banyak pasangan variabel menunjukkan hubungan yang monoton. Sebagai contoh:

• Harga gas untuk perjalanan meningkat secara monoton dalam jarak yang ditempuh.
• Kemungkinan menerima pinjaman lebih besar dengan kredit yang lebih baik.
• Waktu mengemudi yang diharapkan meningkat dengan jumlah lalu lintas.
• Pendapatan meningkat dengan rasio klik pada iklan.

Meskipun hubungan logis ini cukup jelas, untuk model ML yang diinterpolasi menggunakan data terbatas dan tanpa pengetahuan domain, mungkin tidak demikian. Faktanya, model mungkin salah menginterpolasinya, menghasilkan prediksi yang konyol dan aneh. Model pembelajaran mesin yang menangkap pengetahuan tersebut berkinerja lebih baik dalam praktiknya (dengan menghindari overfitting), lebih mudah untuk di-debug, dan lebih dapat ditafsirkan. Dalam kebanyakan kasus penggunaan, model monoton harus digunakan bersama dengan model biasa, sebagai bagian dari ansambel peserta didik.

Satu tempat di mana model AI monoton benar-benar bersinar adalah dalam kekokohan permusuhan. Model monoton adalah model pembelajaran mesin yang "dikeraskan", artinya model tersebut tahan terhadap serangan permusuhan. Penyerang yang hanya mampu memanipulasi fitur non-monotonik tidak dapat menghindari model AI monoton karena mereka tidak dapat mengubah label contoh sehubungan dengan model AI monoton.

Gunakan Kasus untuk Model AI Monotonik

Sejauh ini, diskusi ini sepenuhnya bersifat teoretis. Mari kita bahas beberapa kasus penggunaan kehidupan nyata.

Kasus Penggunaan #1: Deteksi Malware

Salah satu kasus penggunaan paling keren untuk model AI monoton adalah penggunaannya dalam deteksi malware. Diimplementasikan sebagai bagian dari Windows Defender, model monoton hadir di setiap perangkat Windows terbaru, secara diam-diam melindungi pengguna dari malware.

Dalam satu skenario, pembuat malware menyamar sebagai bisnis terdaftar yang sah untuk menipu otoritas sertifikat, berhasil menandatangani kode malware mereka secara digital dengan sertifikat tepercaya. Pengklasifikasi malware yang naif kemungkinan akan menggunakan penandatanganan kode sebagai fitur dan akan menunjukkan sampel tersebut tidak berbahaya.

Namun tidak demikian halnya dengan model AI monotonic Windows Defender, yang fitur monotonnya hanya merupakan fitur yang mengindikasikan malware. Tidak peduli berapa banyak pembuat malware konten "jinak" yang disuntikkan ke malware mereka, model AI monoton Windows Defender akan terus menangkap sampel dan melindungi pengguna dari kerusakan.

Dalam kursus saya, Pembelajaran Mesin untuk Peretas Tim Merah, saya mengajarkan beberapa teknik untuk menghindari pengklasifikasi malware berbasis ML. Salah satu tekniknya terdiri dari memasukkan sampel berbahaya dengan konten/fitur “jinak” untuk menghindari model ML yang naif. Model monoton tahan terhadap serangan ini dan memaksa aktor jahat bekerja lebih keras jika mereka ingin menghindari pengklasifikasi.

Kasus Penggunaan #2: Pemfilteran Konten

Misalkan sebuah tim sedang membuat filter konten penelusuran web untuk perpustakaan sekolah. Model AI monoton adalah kandidat yang bagus untuk digunakan di sini karena forum yang berisi konten yang tidak pantas mungkin juga berisi banyak konten yang dapat diterima.

Pengklasifikasi yang naif mungkin menimbang keberadaan fitur yang "tepat" dengan keberadaan fitur yang "tidak pantas". Tapi itu tidak akan berhasil karena kami tidak ingin anak-anak kami mengakses konten yang tidak pantas, meskipun itu hanya sebagian kecil dari konten tersebut.

Kasus Penggunaan #3: AI Mobil yang Mengemudi Sendiri

Bayangkan membangun algoritma mobil self-driving. Itu terlihat pada gambar dan melihat lampu hijau. Ia juga melihat seorang pejalan kaki. Haruskah itu menimbang sinyal satu sama lain? Sama sekali tidak. Kehadiran pejalan kaki sudah cukup untuk membuat keputusan menghentikan mobil. Kehadiran pejalan kaki harus dilihat sebagai fitur monoton, dan model AI monoton harus digunakan dalam skenario ini.

Kasus Penggunaan #4: Mesin Rekomendasi

Mesin rekomendasi adalah kasus penggunaan yang bagus untuk model AI monoton. Secara umum, mereka mungkin memiliki banyak masukan tentang setiap produk: peringkat bintang, harga, jumlah ulasan, dll. Dengan semua masukan lainnya sama, seperti peringkat bintang dan harga, kami akan lebih memilih produk yang memiliki jumlah ulasan lebih banyak. Kami dapat menerapkan logika tersebut menggunakan model AI monoton.

Kasus Penggunaan #5: Pemfilteran Spam dan Phishing

Kasus penggunaan ini mirip dengan kasus penggunaan deteksi malware. Pengguna jahat dapat menyuntikkan email spam atau phishing mereka dengan istilah yang tampaknya tidak berbahaya untuk mengelabui filter spam. Model AI monoton akan kebal terhadap itu.

Implementasi dan Demonstrasi

Dalam hal implementasi model AI monoton yang tersedia secara bebas, tiga yang paling menonjol adalah yang paling didukung: XGBoost, LightGBM, dan TensorFlow Lattice.

Tutorial Monoton ML XGBoost

XGBoost dianggap sebagai salah satu algoritme berperforma terbaik pada data terstruktur, berdasarkan penelitian dan persaingan empiris selama bertahun-tahun. Selain itu, monotonisitas telah diterapkan di XGBoost.

Tutorial demonstrasi XGBoost berikut tentang cara menggunakan model ML monoton memiliki repo Python yang menyertainya.

Mulailah dengan mengimpor beberapa perpustakaan:

 import random import numpy as np import matplotlib.pyplot as plt %matplotlib inline from sklearn.metrics import confusion_matrix import seaborn as sns sns.set(font_scale=1.4)

Skenario yang akan kita modelkan adalah pemfilteran konten atau database malware. Kami akan memiliki beberapa benign_features , yang modelnya, misalnya, jumlah konten yang terkait dengan "sains", "sejarah", dan "olahraga", atau dalam kasus malware, "penandatanganan kode" dan "penulis yang dikenal".

Selain itu, kami akan memiliki malicious_features , model mana, misalnya, jumlah konten yang terkait dengan "kekerasan" dan "narkoba," atau dalam kasus malware, "berapa kali panggilan ke perpustakaan kripto dilakukan" dan "ukuran numerik dari kesamaan dengan keluarga malware yang dikenal.”

Kami akan memodelkan situasi melalui model generatif. Kami menghasilkan sejumlah besar titik data secara acak, sekitar setengah jinak dan setengah berbahaya, menggunakan fungsi:

 def flip(): """Simulates a coin flip.""" return 1 if random.random() < 0.5 else 0

Setiap titik data akan secara acak menghasilkan fitur-fiturnya. Titik data "jinak" akan memiliki bias yang lebih tinggi untuk fitur jinak, sedangkan titik data "berbahaya" akan memiliki bias yang lebih tinggi untuk fitur berbahaya.

Kami akan menggunakan distribusi segitiga, seperti:

 bins = [0.1 * i for i in range(12)] plt.hist([random.triangular(0, 1, 1) for i in range(50000)], bins) 

Kami akan menggunakan fungsi ini untuk menangkap logika di atas:

 def generate(): """Samples from the triangular distribution.""" return random.triangular(0, 1, 1)

Kemudian, kami akan melanjutkan untuk membuat kumpulan data kami:

 m = 100000 benign_features = 5 malicious_features = 5 n = benign_features + malicious_features benign = 0 malicious = 1 X = np.zeros((m, n)) y = np.zeros((m)) for i in range(m): vec = np.zeros((n)) y[i] = flip() if y[i] == benign: for j in range(benign_features): vec[j] = generate() for j in range(malicious_features): vec[j + benign_features] = 1 - generate() else: for j in range(benign_features): vec[j] = 1 - generate() for j in range(malicious_features): vec[j + benign_features] = generate() X[i, :] = vec

X berisi vektor fitur yang dihasilkan secara acak, sedangkan y berisi label. Masalah klasifikasi ini tidak sepele.

Anda dapat melihat bahwa sampel jinak umumnya memiliki bobot lebih besar dalam beberapa fitur pertama, sedangkan sampel berbahaya umumnya memiliki bobot lebih besar dalam beberapa fitur terakhir.

Dengan data yang sudah siap, mari kita lakukan pemisahan pelatihan-pengujian sederhana:

 from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

Kami akan menggunakan fungsi untuk menyiapkan data untuk digunakan dengan tutorial XGBoost kami:

 import xgboost as xgb def prepare_for_XGBoost(X, y): """Converts a numpy X and y dataset into a DMatrix for XGBoost.""" return xgb.DMatrix(X, label=y) dtrain = prepare_for_XGBoost(X_train, y_train) dtest = prepare_for_XGBoost(X_test, y_test) dall = prepare_for_XGBoost(X, y)

Sekarang, mari kita latih dan uji model XGBoost sederhana (non-monotonik) pada data. Kami kemudian akan mencetak matriks kebingungan untuk melihat perincian numerik dari contoh positif yang diberi label dengan benar, contoh negatif yang diberi label dengan benar, contoh positif yang salah label, dan contoh negatif yang salah label.

 params = {"n_jobs": -1, "tree_method": "hist"} model_no_constraints = xgb.train(params=params, dtrain=dtrain) CM = predict_with_XGBoost_and_return_confusion_matrix( model_no_constraints, dtrain, y_train ) plt.figure(figsize=(12, 10)) sns.heatmap(CM / np.sum(CM), annot=True, fmt=".2%", cmap="Blues") plt.ylabel("True Label") plt.xlabel("Predicted Label") plt.title("Unconstrained model's training confusion matrix") plt.show() print() CM = predict_with_XGBoost_and_return_confusion_matrix( model_no_constraints, dtest, y_test ) plt.figure(figsize=(12, 10)) sns.heatmap(CM / np.sum(CM), annot=True, fmt=".2%", cmap="Blues") plt.ylabel("True Label") plt.xlabel("Predicted Label") plt.title("Unconstrained model's testing confusion matrix") plt.show() model_no_constraints = xgb.train(params=params, dtrain=dall) 

Melihat hasilnya, kita dapat melihat bahwa tidak ada overfitting yang signifikan. Kami akan membandingkan hasil ini dengan model monoton.

Untuk itu, mari kita latih dan uji model XGBoost yang monoton. Sintaks di mana kita melewati kendala monoton adalah urutan ( f ₀ , f ₁ , …, f _N ), di mana setiap f _i adalah salah satu dari -1, 0 atau 1, tergantung pada apakah kita ingin fitur i menjadi monoton menurun, tidak dibatasi, atau monoton meningkat, masing-masing. Dalam kasus yang dihadapi, kami menetapkan fitur berbahaya menjadi peningkatan monoton.

 params_constrained = params.copy() monotone_constraints = ( "(" + ",".join([str(0) for m in range(benign_features)]) + "," + ",".join([str(1) for m in range(malicious_features)]) + ")" ) print("Monotone constraints enforced are:") print(monotone_constraints) params_constrained["monotone_constraints"] = monotone_constraints model_monotonic = xgb.train(params=params_constrained, dtrain=dtrain) CM = predict_with_XGBoost_and_return_confusion_matrix(model_monotonic, dtrain, y_train) plt.figure(figsize=(12, 10)) sns.heatmap(CM / np.sum(CM), annot=True, fmt=".2%", cmap="Blues") plt.ylabel("True Label") plt.xlabel("Predicted Label") plt.title("Monotonic model's training confusion matrix") plt.show() print() CM = predict_with_XGBoost_and_return_confusion_matrix(model_monotonic, dtest, y_test) plt.figure(figsize=(12, 10)) sns.heatmap(CM / np.sum(CM), annot=True, fmt=".2%", cmap="Blues") plt.ylabel("True Label") plt.xlabel("Predicted Label") plt.title("Monotonic model's testing confusion matrix") plt.show() model_monotonic = xgb.train(params=params_constrained, dtrain=dall) 

Jelas bahwa kinerja model monotonik sama dengan model tanpa kendala.

Sekarang, kita akan membuat dataset permusuhan. Kami akan mengambil semua sampel berbahaya dan "mengisi" fitur jinak mereka dengan mengatur semuanya ke 1. Kami kemudian akan melihat bagaimana kedua model bekerja berdampingan.

 X_adversarial = X[y == malicious] y_adversarial = len(X_adversarial) * [malicious] for i in range(len(X_adversarial)): vec = X_adversarial[i, :] for j in range(benign_features): vec[j] = 1 X_adversarial[i, :] = vec

Mari kita ubah ini menjadi bentuk yang akan diserap oleh XGBoost:

 dadv = prepare_for_XGBoost(X_adversarial, y_adversarial)

Untuk langkah terakhir dari tutorial XGBoost kami, kami akan menguji dua jenis model pembelajaran mesin:

 CM = predict_with_XGBoost_and_return_confusion_matrix( model_no_constraints, dadv, y_adversarial ) plt.figure(figsize=(12, 10)) sns.heatmap(CM / np.sum(CM), annot=True, fmt=".2%", cmap="Blues") plt.ylabel("True Label") plt.xlabel("Predicted Label") plt.title("Unconstrained model's confusion matrix on adversarial dataset") plt.show()

 CM = predict_with_XGBoost_and_return_confusion_matrix( model_monotonic, dadv, y_adversarial ) plt.figure(figsize=(12, 10)) sns.heatmap(CM / np.sum(CM), annot=True, fmt=".2%", cmap="Blues") plt.ylabel("True Label") plt.xlabel("Predicted Label") plt.title("Monotonic model's confusion matrix on adversarial dataset") plt.show() 

Seperti yang Anda lihat, model AI monoton sekitar 2.500 kali lebih kuat terhadap serangan musuh.

Cahaya GBM

Sintaks untuk menggunakan fitur monoton di LightGBM serupa.

Kisi TensorFlow

TensorFlow Lattice adalah kerangka kerja lain untuk mengatasi kendala monoton dan merupakan kumpulan Penaksir TensorFlow bawaan serta operator TensorFlow untuk membangun model kisi Anda sendiri. Kisi-kisi adalah tabel pencarian interpolasi multi-dimensi, artinya mereka adalah titik yang didistribusikan secara merata dalam ruang (seperti kisi), bersama dengan nilai fungsi pada titik-titik ini. Menurut Blog Google AI:

“...nilai tabel pencarian dilatih untuk meminimalkan kerugian pada contoh pelatihan, tetapi selain itu, nilai yang berdekatan dalam tabel pencarian dibatasi untuk meningkat sepanjang arah ruang input yang diberikan, yang membuat output model meningkat dalam arah tersebut. Yang penting, karena mereka menginterpolasi antara nilai tabel pencarian, model kisi mulus dan prediksi dibatasi, yang membantu menghindari prediksi besar atau kecil palsu dalam waktu pengujian.”

Tutorial cara menggunakan TensorFlow Lattice dapat ditemukan di sini.

Model AI Monotonik dan Masa Depan

Dari mempertahankan perangkat dari serangan jahat hingga menawarkan rekomendasi restoran yang logis dan bermanfaat, model AI monoton telah terbukti menjadi anugerah besar bagi masyarakat dan alat yang luar biasa untuk dikuasai. Model monoton hadir untuk mengantar kita ke era baru keamanan, kemahiran, dan pemahaman dalam AI. Jadi saya katakan, ini untuk model AI monoton, ini untuk kemajuan.