Logica sonora e modelli di intelligenza artificiale monotona

L'intelligenza artificiale sta rapidamente diventando una risorsa straordinaria, avendo raggiunto livelli di prestazioni sovrumani in domini come il riconoscimento delle immagini, il Go e persino il poker. Molti sono entusiasti del futuro dell'IA e dell'umanità. Allo stesso tempo, c'è la sensazione generale che l'IA soffra di un fastidioso difetto: l'IA nel suo stato attuale può essere imprevedibilmente inaffidabile.

L'esempio classico è il pericolo! IBM Challenge , durante il quale Watson, l'IA IBM, ha pulito il tabellone con facilità, solo per perdere il "Final Jeopardy!" domanda, che rientrava nella categoria delle città degli Stati Uniti : “Il suo aeroporto più grande prende il nome da un eroe della seconda guerra mondiale; è la seconda più grande per una battaglia della seconda guerra mondiale. Watson ha risposto: "Cos'è Toronto??????", i punti interrogativi extra (e la scommessa bassa) che indicano il suo dubbio.

Quindi, anche se l'IA ha la capacità di eseguire prestazioni da favola per ampi periodi di tempo - mesi, anni, persino decenni - c'è sempre questa possibilità fastidiosa che all'improvviso, commetterà misteriosamente un errore.

La cosa più preoccupante per noi umani non è che l'IA commetterà un errore, ma quanto sarà "illogico" l'errore. Nel caso di Watson, qualcuno che non conosce la risposta alla domanda proverebbe "logicamente" almeno a indovinare una grande città degli Stati Uniti. Credo che questo sia uno dei motivi principali per cui non abbiamo ancora adottato pubblicamente le auto a guida autonoma: anche se le auto a guida autonoma possono essere statisticamente più sicure, temiamo che la loro IA sottostante possa inaspettatamente sbagliare in un senso simile a quello di Watson , ma con ripercussioni ben più gravi.

Questo mi ha fatto chiedere, il modello di IA giusto potrebbe risolvere questo problema? La giusta IA potrebbe avere la capacità di prendere decisioni valide nei momenti critici, anche quando non ha tutte le risposte? Tale IA sarebbe in grado di cambiare il corso della tecnologia e permetterci i vantaggi fiabeschi dell'IA...

Credo che la risposta a queste domande sia sì. Credo che errori come quello di Watson possano essere evitati con l'uso di modelli migliorati e più logicamente vincolati, il primo prototipo dei quali sono chiamati modelli di apprendimento automatico monotonici . Senza entrare ancora nei dettagli, con il modello di IA monotona corretto:

• Un'auto a guida autonoma sarebbe più sicura, in quanto il rilevamento anche della più piccola quantità di segnale umano sarebbe sempre sufficiente per attivare un protocollo di sicurezza anche in presenza di una grande quantità di altro segnale.
• I sistemi di machine learning (ML) sarebbero più resistenti agli attacchi del contraddittorio e alle situazioni impreviste.
• Le prestazioni del ML sarebbero più logiche e umanamente comprensibili.

Credo che stiamo passando da un'era di grande crescita del potere computazionale e algoritmico dell'IA a un'era di finezza, efficacia e comprensione dell'IA, e i modelli monotoni di machine learning sono il primo passo di questo entusiasmante viaggio. I modelli monotoni rendono l'IA più "logica".

Nota del redattore: i lettori che desiderano fare i primi passi nella comprensione delle basi del ML sono incoraggiati a leggere il nostro articolo introduttivo sul ML.

La teoria dei modelli di IA monotona

Allora, cos'è un modello monotono? In parole povere, un modello monotono è un modello ML che ha un insieme di funzionalità ( caratteristiche monotoniche ) il cui aumento porta sempre il modello ad aumentare il proprio output.

Nella vita reale, molte coppie di variabili mostrano relazioni monotone. Per esempio:

• Il prezzo del gas per un viaggio aumenta in modo monotono nella distanza percorsa.
• La probabilità di ricevere un prestito è maggiore con un credito migliore.
• Il tempo di guida previsto aumenta con la quantità di traffico.
• Le entrate aumentano con la percentuale di clic su un annuncio.

Sebbene queste relazioni logiche siano abbastanza chiare, per un modello ML che interpola utilizzando dati limitati e nessuna conoscenza del dominio, potrebbero non esserlo. In effetti, il modello potrebbe interpolarli in modo errato, risultando in previsioni ridicole e stravaganti. I modelli di apprendimento automatico che acquisiscono tale conoscenza funzionano meglio nella pratica (evitando l'overfitting), sono più facili da eseguire il debug e sono più interpretabili. Nella maggior parte dei casi d'uso, il modello monotono dovrebbe essere utilizzato insieme a un modello ordinario, come parte di un insieme di discenti.

Un punto in cui i modelli di IA monotona brillano davvero è nella robustezza del contraddittorio. I modelli monotonici sono modelli di apprendimento automatico "rafforzati", il che significa che sono resistenti agli attacchi del contraddittorio. Gli aggressori che sono in grado di manipolare solo caratteristiche non monotoniche non sono in grado di eludere il modello di IA monotona perché non sono in grado di modificare l'etichetta dell'esempio rispetto al modello di IA monotona.

Casi d'uso per modelli di IA monotona

Finora, questa discussione è stata del tutto teorica. Discutiamo di alcuni casi d'uso nella vita reale.

Caso d'uso n. 1: rilevamento di malware

Uno dei casi d'uso più interessanti per i modelli di intelligenza artificiale monotona deve essere il loro utilizzo nel rilevamento di malware. Implementato come parte di Windows Defender, un modello monotono è presente in ogni dispositivo Windows aggiornato, proteggendo silenziosamente gli utenti dal malware.

In uno scenario, gli autori di malware hanno impersonato aziende legittime e registrate per frodare le autorità di certificazione, firmando con successo il codice digitale del loro malware con certificati attendibili. È probabile che un classificatore di malware ingenuo utilizzi la firma del codice come funzionalità e indicherebbe che tali campioni sono benigni.

Ma non è così nel caso del modello di intelligenza artificiale monotona di Windows Defender, le cui caratteristiche monotone sono solo quelle che indicano malware. Indipendentemente dalla quantità di contenuti "benigni" che gli autori di malware iniettano nel loro malware, il modello di IA monotona di Windows Defender continuerà a catturare il campione e a difendere gli utenti dai danni.

Nel mio corso, Machine Learning for Red Team Hackers, insegno diverse tecniche per eludere i classificatori di malware basati su ML. Una delle tecniche consiste nel riempire un campione dannoso con contenuti/caratteristiche "benigne" per eludere i modelli ML ingenui. I modelli monotoni sono resistenti a questo attacco e costringono gli attori malintenzionati a lavorare molto più duramente se vogliono avere qualche speranza di eludere il classificatore.

Caso d'uso n. 2: filtro dei contenuti

Supponiamo che un team stia costruendo un filtro dei contenuti per la navigazione sul Web per le biblioteche scolastiche. Un modello di intelligenza artificiale monotona è un ottimo candidato da utilizzare qui perché un forum che contiene contenuti inappropriati potrebbe anche contenere molti contenuti accettabili.

Un classificatore ingenuo potrebbe soppesare la presenza di caratteristiche "appropriate" rispetto alla presenza di caratteristiche "inappropriate". Ma ciò non va, poiché non vogliamo che i nostri figli accedano a contenuti inappropriati, anche se costituiscono solo una piccola parte dei contenuti.

Caso d'uso n. 3: IA per auto a guida autonoma

Immagina di costruire un algoritmo per auto a guida autonoma. Guarda un'immagine e vede una luce verde. Vede anche un pedone. Dovrebbe pesare il segnale di ciascuno contro l'altro? Assolutamente no. La presenza di un pedone è sufficiente per decidere di fermare l'auto. La presenza di pedoni dovrebbe essere vista come una caratteristica monotona e in questo scenario dovrebbe essere utilizzato un modello di IA monotona.

Caso d'uso n. 4: Motori di raccomandazione

I motori di raccomandazione sono un ottimo caso d'uso per i modelli di intelligenza artificiale monotona. In generale, potrebbero avere molti input su ciascun prodotto: valutazione a stelle, prezzo, numero di recensioni, ecc. A parità di tutti gli altri input, come valutazioni a stelle e prezzo, preferiremmo il prodotto con un numero maggiore di recensioni. Possiamo applicare tale logica usando un modello di IA monotono.

Caso d'uso n. 5: filtro antispam e phishing

Questo caso d'uso è simile al caso d'uso del rilevamento di malware. Gli utenti malintenzionati possono iniettare nelle loro e-mail di spam o phishing termini apparentemente benigni per ingannare i filtri antispam. Un modello di IA monotona ne sarà immune.

Attuazione e dimostrazione

Quando si tratta di implementazioni disponibili gratuitamente di modelli di intelligenza artificiale monotona, tre si distinguono per il miglior supporto: XGBoost, LightGBM e TensorFlow Lattice.

Tutorial ML XGBoost monotono

XGBoost è considerato uno degli algoritmi più performanti sui dati strutturati, sulla base di anni di ricerca empirica e concorrenza. Inoltre, la monotonia è stata implementata in XGBoost.

Il seguente tutorial dimostrativo di XGBoost su come usare i modelli ML monotonici include un repository Python di accompagnamento.

Inizia importando alcune librerie:

 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)

Lo scenario che modelliamo è un database di filtri dei contenuti o malware. Avremo alcune benign_features , che modellano, ad esempio, la quantità di contenuti relativi a "scienza", "storia" e "sport" o, nel caso del malware, "firma del codice" e "autori riconosciuti".

Inoltre, avremo malicious_features , che modellano, ad esempio, la quantità di contenuti relativi a "violenza" e "droghe" o, nel caso del malware, "il numero di chiamate alle librerie crittografiche" e "una misura numerica di somiglianza con una nota famiglia di malware".

Modelleremo la situazione attraverso un modello generativo. Generiamo un gran numero di punti dati in modo casuale, circa metà benigni e metà dannosi, utilizzando la funzione:

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

Ogni punto dati genererà casualmente le sue caratteristiche. Un punto dati "benigno" avrà una maggiore propensione per le funzioni benigne, mentre un punto dati "dannoso" avrà una propensione maggiore per le funzioni dannose.

Useremo una distribuzione triangolare, in questo modo:

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

Useremo questa funzione per acquisire la logica sopra:

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

Quindi, procederemo alla creazione del nostro set di dati:

 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 contiene i vettori delle caratteristiche generate casualmente, mentre y contiene le etichette. Questo problema di classificazione non è banale.

Puoi vedere che i campioni benigni generalmente hanno un peso maggiore nelle prime funzionalità, mentre i campioni dannosi generalmente hanno un peso maggiore nelle ultime funzionalità.

Con i dati pronti, eseguiamo una semplice suddivisione training-test:

 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)

Useremo una funzione per preparare i dati per l'uso con il nostro tutorial 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)

Ora, alleniamo e testiamo un modello XGBoost semplice (non monotono) sui dati. Stamperemo quindi la matrice di confusione per vedere una ripartizione numerica degli esempi positivi correttamente etichettati, degli esempi negativi correttamente etichettati, degli esempi positivi etichettati in modo errato e degli esempi negativi etichettati in modo errato.

 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) 

Guardando i risultati, possiamo vedere che non c'è un overfitting significativo. Confronteremo questi risultati con quelli dei modelli monotoni.

A tal fine, alleniamo e testiamo un modello XGBoost monotono. La sintassi in cui passiamo nei vincoli di monotono è una sequenza ( f ₀ , f ₁ , …, f _N ), dove ogni f _i è uno tra -1, 0 o 1, a seconda che si desideri che la caratteristica i sia monotona rispettivamente decrescente, non vincolato o monotonicamente crescente. Nel caso in questione, specifichiamo che le funzionalità dannose siano in aumento monotono.

 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) 

È chiaro che le prestazioni del modello monotono sono le stesse di quelle del modello non vincolato.

Ora creeremo un set di dati contraddittorio. Prenderemo tutti i campioni dannosi e "riempiremo" le loro caratteristiche benigne impostandoli tutti su 1. Vedremo quindi come si comportano i due modelli fianco a fianco.

 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

Convertiamoli in un modulo da inserire da XGBoost:

 dadv = prepare_for_XGBoost(X_adversarial, y_adversarial)

Per il passaggio finale del nostro tutorial XGBoost, testeremo i due tipi di modelli di machine learning:

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

Come puoi vedere, il modello di IA monotona era circa 2.500 volte più robusto agli attacchi avversari.

LightGBM

La sintassi per l'utilizzo di funzionalità monotone in LightGBM è simile.

Reticolo TensorFlow

TensorFlow Lattice è un altro framework per affrontare i vincoli di monotonicità ed è un insieme di stimatori TensorFlow predefiniti e operatori TensorFlow per costruire i propri modelli reticolari. I reticoli sono tabelle di ricerca interpolate multidimensionali, il che significa che sono punti distribuiti uniformemente nello spazio (come una griglia), insieme a valori di funzione in questi punti. Secondo il blog di Google AI:

"... i valori della tabella di ricerca vengono addestrati per ridurre al minimo la perdita negli esempi di addestramento, ma in aggiunta, i valori adiacenti nella tabella di ricerca sono vincolati ad aumentare lungo determinate direzioni dello spazio di input, il che fa aumentare gli output del modello in quelle direzioni. È importante sottolineare che, poiché si interpolano tra i valori della tabella di ricerca, i modelli reticolari sono fluidi e le previsioni sono limitate, il che aiuta a evitare previsioni spurie grandi o piccole nel tempo di test".

I tutorial su come utilizzare TensorFlow Lattice sono disponibili qui.

Modelli di IA monotona e futuro

Dalla difesa dei dispositivi da attacchi dannosi all'offerta di consigli logici e utili sui ristoranti, i modelli di IA monotona hanno dimostrato di essere un grande vantaggio per la società e uno strumento meraviglioso da padroneggiare. I modelli monotoni sono qui per inaugurarci una nuova era di sicurezza, finezza e comprensione nell'IA. E quindi dico, ecco i modelli di intelligenza artificiale monotona, ecco i progressi.