Sunet logic și modele AI monotone

AI devine rapid un activ uimitor, atins niveluri supraomenești de performanță în domenii precum recunoașterea imaginilor, Go și chiar pokerul. Mulți sunt încântați de viitorul AI și al umanității. În același timp, există un sentiment general că AI suferă de un defect neplăcut: AI în starea sa actuală poate fi imprevizibil de nesigur.

Exemplul clasic este Jeopardy! IBM Challenge , în timpul căreia Watson, IBM AI, a curățat placa cu ușurință, doar pentru a rata „Final Jeopardy!” întrebare, care se afla în categoria orașelor din SUA : „Cel mai mare aeroport al său este numit pentru un erou al celui de-al doilea război mondial; al doilea ca mărime pentru o bătălie din al Doilea Război Mondial.” Watson a răspuns: „Ce este Toronto?????” – semnele suplimentare de întrebare (și pariul scăzut) indicând îndoiala sa.

Așa că, deși AI are capacitatea de a avea performanțe ca de basm pentru perioade mari de timp - luni, ani, chiar decenii - există întotdeauna această posibilitate sâcâitoare că, dintr-o dată, va greși în mod misterios.

Cel mai important pentru noi, oamenii, nu este faptul că AI va face o greșeală, ci cât de „ilogică” va fi greșeala. În cazul lui Watson, cineva care nu știe răspunsul la întrebare ar încerca „logic” să ghicească cel puțin un oraș important din SUA. Cred că acesta este unul dintre motivele principale pentru care nu avem încă adoptarea publică a mașinilor care se conduc singure: chiar dacă mașinile care se conduc singure pot fi mai sigure din punct de vedere statistic, ne temem că AI-ul lor subiacent ar putea greși în mod neașteptat, într-un sens similar cu Watson. , dar cu repercusiuni mult mai grave.

Acest lucru m-a făcut să mă întreb, ar putea modelul AI potrivit să remedieze această problemă? Ar putea AI-ul potrivit să aibă capacitatea de a lua decizii sănătoase în momentele critice, chiar și atunci când nu are toate răspunsurile? O astfel de IA ar putea să schimbe cursul tehnologiei și să ne permită beneficiile de basm ale AI...

Cred că răspunsul la aceste întrebări este da. Cred că greșeli precum cea a lui Watson pot fi evitate prin utilizarea unor modele îmbunătățite, mai limitate din punct de vedere logic, al căror prototip timpuriu se numește modele monotone de învățare automată . Fără a intra în detalii încă, cu modelul AI monoton adecvat:

• O mașină cu conducere autonomă ar fi mai sigură, deoarece detectarea chiar și a celei mai mici cantități de semnal uman ar fi întotdeauna suficientă pentru a activa un protocol de siguranță chiar și în prezența unei cantități mari de alt semnal.
• Sistemele de învățare automată (ML) ar fi mai robuste în fața atacurilor adverse și a situațiilor neașteptate.
• Performanța ML ar fi mai logică și mai ușor de înțeles uman.

Cred că trecem de la o eră de mare creștere a puterii computaționale și algoritmice a AI la o eră a fineței, eficacității și înțelegerii în AI, iar modelele monotone de învățare automată sunt primul pas în această călătorie interesantă. Modelele monotone fac AI mai „logică”.

Nota editorului: Cititorii care doresc să facă primul pas în înțelegerea elementelor de bază ale ML sunt încurajați să citească articolul nostru introductiv despre ML.

Teoria modelelor monotone AI

Deci, ce este un model monoton? Vorbind, un model monoton este un model ML care are un set de caracteristici (trăsături monotone ) a căror creștere determină întotdeauna modelul să își mărească producția.

În viața reală, multe perechi de variabile prezintă relații monotone. De exemplu:

• Prețul benzinei pentru o călătorie crește monoton pe distanța parcursă.
• Probabilitatea de a primi un împrumut este mai mare cu un credit mai bun.
• Timpul de condus estimat crește odată cu volumul de trafic.
• Venitul crește odată cu rata de clic pe un anunț.

Deși aceste relații logice sunt suficient de clare, pentru un model ML care se interpolează folosind date limitate și fără cunoștințe de domeniu, s-ar putea să nu fie. De fapt, modelul le-ar putea interpola incorect, rezultând predicții ridicole și ciudate. Modelele de învățare automată care captează astfel de cunoștințe funcționează mai bine în practică (prin evitarea supraadaptării), sunt mai ușor de depanat și sunt mai interpretabile. În majoritatea cazurilor de utilizare, modelul monoton ar trebui utilizat împreună cu un model obișnuit, ca parte a unui ansamblu de cursanți.

Un loc în care modelele monotone AI strălucesc cu adevărat este în robustețea adversarului. Modelele monotone sunt modele de învățare automată „întărite”, ceea ce înseamnă că sunt rezistente la atacurile adverse. Atacatorii care sunt capabili să manipuleze numai caracteristicile nemonotone nu pot evita modelul monoton AI, deoarece nu pot modifica eticheta exemplului în raport cu modelul monoton AI.

Cazuri de utilizare pentru modelele AI monotone

Până acum, această discuție a fost în întregime teoretică. Să discutăm câteva cazuri de utilizare din viața reală.

Cazul de utilizare #1: Detectarea programelor malware

Unul dintre cele mai interesante cazuri de utilizare pentru modelele monotone AI trebuie să fie utilizarea lor în detectarea malware-ului. Implementat ca parte a Windows Defender, un model monoton este prezent în fiecare dispozitiv Windows actualizat, protejând în liniște utilizatorii de malware.

Într-unul dintre scenarii, autorii de programe malware și-au uzurpat identitatea unor companii legitime, înregistrate, pentru a frauda autoritățile de certificare, semnându-și cu succes codul digital cu certificate de încredere. Un clasificator naiv de malware este probabil să folosească semnarea codului ca caracteristică și ar indica ca astfel de mostre sunt benigne.

Dar nu este așa și în cazul modelului AI monoton al Windows Defender, ale cărui caracteristici monotone sunt doar caracteristicile care indică malware. Indiferent cât de mult conținut „benign” injectează autorii malware în malware-ul lor, modelul monoton AI al Windows Defender va continua să prindă eșantionul și să apere utilizatorii de daune.

În cursul meu, Machine Learning pentru Red Team Hackers, predau mai multe tehnici pentru a evita clasificatorii de malware bazați pe ML. Una dintre tehnici constă în umplerea unui eșantion rău intenționat cu conținut/funcții „benigne” pentru a evita modelele ML naive. Modelele monotone sunt rezistente la acest atac și îi obligă pe actorii rău intenționați să muncească mult mai mult dacă vor să aibă vreo speranță de a se sustrage de la clasificator.

Cazul de utilizare nr. 2: filtrarea conținutului

Să presupunem că o echipă construiește un filtru de conținut pentru navigarea pe web pentru bibliotecile școlare. Un model AI monoton este un candidat excelent pentru a fi folosit aici, deoarece un forum care conține conținut neadecvat ar putea conține, de asemenea, o mulțime de conținut acceptabil.

Un clasificator naiv ar putea cântări prezența trăsăturilor „adecvate” cu prezența trăsăturilor „nepotrivite”. Dar asta nu va funcționa, deoarece nu dorim ca copiii noștri să acceseze conținut neadecvat, chiar dacă acesta reprezintă doar o mică parte din conținut.

Cazul de utilizare nr. 3: Inteligența artificială a mașinilor cu conducere autonomă

Imaginați-vă că construiți un algoritm de mașină autonomă. Se uită la o imagine și vede o lumină verde. Vede și un pieton. Ar trebui să cântărească semnalul unul față de celălalt? Absolut nu. Prezența unui pieton este suficientă pentru a lua decizia de a opri mașina. Prezența pietonilor ar trebui privită ca o caracteristică monotonă, iar în acest scenariu ar trebui utilizat un model AI monoton.

Cazul de utilizare #4: Motoare de recomandare

Motoarele de recomandare sunt un caz de utilizare excelent pentru modelele AI monotone. În general, acestea ar putea avea multe intrări despre fiecare produs: evaluare cu stele, preț, număr de recenzii etc. Cu toate celelalte intrări fiind egale, cum ar fi evaluările cu stele și prețul, am prefera produsul care are un număr mai mare de recenzii. Putem aplica o astfel de logică folosind un model AI monoton.

Cazul de utilizare nr. 5: filtrarea spamului și a phishingului

Acest caz de utilizare este similar cu cazul de utilizare pentru detectarea programelor malware. Utilizatorii rău intenționați își pot injecta e-mailurile de spam sau de phishing cu termeni aparent inofensivi pentru a păcăli filtrele de spam. Un model AI monoton va fi imun la asta.

Implementare și demonstrație

Când vine vorba de implementări disponibile gratuit ale modelelor AI monotone, trei se remarcă ca fiind cele mai bine acceptate: XGBoost, LightGBM și TensorFlow Lattice.

Tutorial monotonic ML XGBoost

XGBoost este considerat unul dintre algoritmii cu cele mai bune performanțe în ceea ce privește datele structurate, bazat pe ani de cercetare empirică și competiție. În plus, monotonitatea a fost implementată în XGBoost.

Următorul tutorial demonstrativ XGBoost despre cum să utilizați modelele ML monotone are un depozit Python însoțitor.

Începeți prin a importa câteva biblioteci:

 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)

Scenariul pe care îl vom modela este o bază de date de filtrare a conținutului sau malware. Vom avea unele benign_features , care modelează, de exemplu, cantitatea de conținut legată de „știință”, „istorie” și „sport” sau, în cazul programelor malware, „semnare de cod” și „autori recunoscuți”.

De asemenea, vom avea malicious_features , care modelează, de exemplu, cantitatea de conținut legată de „violență” și „droguri” sau, în cazul programelor malware, „numărul de apeluri către biblioteci criptografice” și „o măsură numerică a similaritate cu o familie cunoscută de programe malware.”

Vom modela situația printr-un model generativ. Generăm un număr mare de puncte de date la întâmplare, aproximativ jumătate benigne și jumătate rău intenționate, folosind funcția:

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

Fiecare punct de date își va genera aleatoriu caracteristicile. Un punct de date „benign” va avea o părtinire mai mare pentru caracteristicile benigne, în timp ce un punct de date „răușitor” va avea o părtinire mai mare pentru caracteristicile rău intenționate.

Vom folosi o distribuție triunghiulară, astfel:

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

Vom folosi această funcție pentru a capta logica de mai sus:

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

Apoi, vom continua la crearea setului nostru de date:

 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 conține vectorii caracteristicilor generate aleator, în timp ce y conține etichetele. Această problemă de clasificare nu este banală.

Puteți observa că mostrele benigne au în general o greutate mai mare în primele câteva caracteristici, în timp ce mostrele rău intenționate au, în general, o greutate mai mare în ultimele câteva caracteristici.

Cu datele gata, să efectuăm o împărțire simplă de antrenament-testare:

 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)

Vom folosi o funcție pentru a pregăti datele pentru utilizare cu tutorialul nostru XGBoost:

 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)

Acum, să antrenăm și să testăm un model XGBoost simplu (nemonoton) pe date. Vom imprima apoi matricea de confuzie pentru a vedea o defalcare numerică a exemplelor pozitive etichetate corect, exemplelor negative etichetate corect, exemplelor pozitive etichetate incorect și exemplelor negative etichetate incorect.

 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) 

Privind rezultatele, putem observa că nu există o supraadaptare semnificativă. Vom compara aceste rezultate cu cele ale modelelor monotone.

În acest scop, să antrenăm și să testăm un model XGBoost monoton. Sintaxa în care trecem în constrângerile monotone este o succesiune ( f ₀ , f ₁ , …, f _N ), în care fiecare f _i este unul dintre -1, 0 sau 1, în funcție de faptul dacă dorim ca caracteristica i să fie monoton în scădere, neconstrâns sau, respectiv, în creștere monoton. În cazul de față, specificăm caracteristicile rău intenționate să fie în creștere monotone.

 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) 

Este clar că performanța modelului monoton este aceeași cu cea a modelului neconstrâns.

Acum, vom crea un set de date adverse. Vom lua toate eșantioanele rău intenționate și vom „umple” caracteristicile lor benigne, setându-le pe toate la 1. Vom vedea apoi cum funcționează cele două modele unul lângă altul.

 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

Să le convertim într-un formular pentru a fi ingerat de XGBoost:

 dadv = prepare_for_XGBoost(X_adversarial, y_adversarial)

Pentru pasul final al tutorialului nostru XGBoost, vom testa cele două tipuri de modele de învățare automată:

 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() 

După cum puteți vedea, modelul monoton AI a fost de aproximativ 2.500 de ori mai robust la atacurile adverse.

LightGBM

Sintaxa pentru utilizarea caracteristicilor monotone în LightGBM este similară.

TensorFlow Lattice

TensorFlow Lattice este un alt cadru pentru abordarea constrângerilor de monotonitate și este un set de estimatori TensorFlow prefabricați, precum și operatori TensorFlow pentru a vă construi propriile modele de rețea. Rețelele sunt tabele de căutare interpolate multidimensionale, ceea ce înseamnă că sunt puncte distribuite uniform în spațiu (ca o grilă), împreună cu valorile funcției în aceste puncte. Conform blogului Google AI:

„...valorile tabelului de căutare sunt antrenate pentru a minimiza pierderea din exemplele de antrenament, dar în plus, valorile adiacente din tabelul de căutare sunt constrânse să crească de-a lungul direcțiilor date ale spațiului de intrare, ceea ce face ca ieșirile modelului să crească în acele direcții. Este important, deoarece interpolează între valorile tabelului de căutare, modelele de rețea sunt netede, iar predicțiile sunt mărginite, ceea ce ajută la evitarea predicțiilor false mari sau mici în timpul testării.”

Tutoriale despre cum să utilizați TensorFlow Lattice pot fi găsite aici.

Modele monotone AI și viitor

De la apărarea dispozitivelor de atacuri rău intenționate până la oferirea de recomandări logice și utile pentru restaurante, modelele monotone AI s-au dovedit a fi o mare binefacere pentru societate și un instrument minunat de stăpânit. Modelele monotone sunt aici pentru a ne introduce într-o nouă eră de siguranță, finețe și înțelegere în AI. Și așa spun, iată modelele monotone de AI, iată pentru progres.