Soundlogik und monotone KI-Modelle

KI entwickelt sich schnell zu einem erstaunlichen Vorteil, da sie in Bereichen wie Bilderkennung, Go und sogar Poker übermenschliche Leistungen erzielt hat. Viele sind gespannt auf die Zukunft der KI und der Menschheit. Gleichzeitig besteht das allgemeine Gefühl, dass KI an einem lästigen Fehler leidet: KI in ihrem aktuellen Zustand kann unvorhersehbar unzuverlässig sein.

Das klassische Beispiel ist Jeopardy! IBM Challenge , bei der Watson, die IBM-KI, das Board mit Leichtigkeit säuberte, nur um die „Final Jeopardy!“ zu verpassen. Frage, die in die Kategorie US-Städte fiel: „Sein größter Flughafen ist nach einem Helden des Zweiten Weltkriegs benannt; seine zweitgrößte für eine Schlacht im Zweiten Weltkrieg.“ Watson antwortete: „Was ist Toronto?????“ – die zusätzlichen Fragezeichen (und der niedrige Einsatz) deuten auf Zweifel hin.

Obwohl die KI die Fähigkeit hat, über lange Zeiträume – Monate, Jahre, sogar Jahrzehnte – märchenhafte Leistungen zu erbringen, besteht immer die quälende Möglichkeit, dass sie plötzlich auf mysteriöse Weise einen Fehler macht.

Die größte Sorge für uns Menschen ist nicht, dass die KI einen Fehler machen wird, sondern wie „unlogisch“ der Fehler sein wird. In Watsons Fall würde jemand, der die Antwort auf die Frage nicht kennt, „logischerweise“ versuchen, zumindest eine US-Großstadt zu erraten. Ich glaube, dass dies einer der Hauptgründe dafür ist, dass wir noch keine öffentliche Einführung von selbstfahrenden Autos haben: Selbst wenn selbstfahrende Autos statistisch gesehen sicherer sein mögen, befürchten wir, dass ihre zugrunde liegende KI in einem ähnlichen Sinne wie Watson unerwartet Fehler machen könnte , aber mit viel schwerwiegenderen Auswirkungen.

Ich habe mich gefragt, ob das richtige KI-Modell dieses Problem beheben kann. Könnte die richtige KI in kritischen Momenten fundierte Entscheidungen treffen, auch wenn sie nicht alle Antworten hat? Eine solche KI wäre in der Lage, den Lauf der Technologie zu ändern und uns die märchenhaften Vorteile der KI zu ermöglichen …

Ich glaube, die Antwort auf diese Fragen ist ja. Ich glaube, dass Fehler wie der von Watson durch die Verwendung verbesserter, logisch eingeschränkterer Modelle vermeidbar sind, deren frühe Prototypen als monotone maschinelle Lernmodelle bezeichnet werden . Ohne jetzt ins Detail zu gehen, mit dem richtigen monotonen KI-Modell:

• Ein selbstfahrendes Auto wäre sicherer, da die Erkennung selbst der kleinsten menschlichen Signale immer ausreichen würde, um ein Sicherheitsprotokoll zu aktivieren, selbst wenn eine große Menge anderer Signale vorhanden ist.
• Systeme für maschinelles Lernen (ML) wären robuster gegenüber gegnerischen Angriffen und unerwarteten Situationen.
• Die ML-Leistung wäre logischer und menschlich verständlicher.

Ich glaube, wir bewegen uns von einer Ära des großen Wachstums der Rechen- und Algorithmenleistung der KI zu einer Ära der Finesse, Effektivität und des Verständnisses der KI, und monotone maschinelle Lernmodelle sind der erste Schritt auf dieser aufregenden Reise. Monotone Modelle machen KI „logischer“.

Anmerkung des Herausgebers: Leser, die ihren eigenen ersten Schritt zum Verständnis der ML-Grundlagen machen möchten, sollten unseren Einführungsartikel zu ML lesen.

Die Theorie monotoner KI-Modelle

Was ist also ein monotones Modell? Grob gesagt ist ein monotones Modell ein ML-Modell, das einige Merkmale ( monotone Merkmale ) aufweist, deren Zunahme immer dazu führt, dass das Modell seine Ausgabe erhöht.

Im wirklichen Leben weisen viele Variablenpaare monotone Beziehungen auf. Zum Beispiel:

• Der Benzinpreis für eine Fahrt steigt mit der gefahrenen Strecke monoton an.
• Die Wahrscheinlichkeit, einen Kredit zu erhalten, ist bei besserer Bonität größer.
• Die zu erwartende Fahrzeit steigt mit dem Verkehrsaufkommen.
• Der Umsatz steigt mit der Klickrate auf eine Anzeige.

Obwohl diese logischen Beziehungen klar genug sind, sind sie es für ein ML-Modell, das mit begrenzten Daten und ohne Domänenwissen interpoliert, möglicherweise nicht. Tatsächlich könnte das Modell sie falsch interpolieren, was zu lächerlichen und verrückten Vorhersagen führt. Machine-Learning-Modelle, die solches Wissen erfassen, funktionieren in der Praxis besser (indem sie eine Überanpassung vermeiden), sind leichter zu debuggen und besser interpretierbar. In den meisten Anwendungsfällen sollte das monotone Modell in Verbindung mit einem gewöhnlichen Modell als Teil eines Ensembles von Lernenden verwendet werden.

Ein Punkt, an dem monotone KI-Modelle wirklich glänzen, ist ihre gegnerische Robustheit. Monotone Modelle sind „gehärtete“ Modelle des maschinellen Lernens, d. h. sie sind resistent gegen gegnerische Angriffe. Angreifer, die nur nicht-monotone Merkmale manipulieren können, können das monotone KI-Modell nicht umgehen, da sie nicht in der Lage sind, die Bezeichnung des Beispiels in Bezug auf das monotone KI-Modell zu ändern.

Anwendungsfälle für monotone KI-Modelle

Bisher war diese Diskussion rein theoretisch. Lassen Sie uns einige Anwendungsfälle aus dem wirklichen Leben besprechen.

Anwendungsfall Nr. 1: Malware-Erkennung

Einer der coolsten Anwendungsfälle für monotone KI-Modelle muss ihre Verwendung bei der Malware-Erkennung sein. Als Teil von Windows Defender implementiert, ist ein monotones Modell in jedem aktuellen Windows-Gerät vorhanden, das Benutzer leise vor Malware schützt.

In einem Szenario gaben sich Malware-Autoren als legitime, registrierte Unternehmen aus, um Zertifizierungsstellen zu betrügen, und signierten ihre Malware erfolgreich digital mit vertrauenswürdigen Zertifikaten. Ein naiver Malware-Klassifikator verwendet wahrscheinlich Code-Signaturen als Funktion und würde solche Beispiele als harmlos bezeichnen.

Nicht so im Fall des monotonen KI-Modells von Windows Defender, dessen monotone Merkmale nur die Merkmale sind, die auf Malware hinweisen. Unabhängig davon, wie viel Malware-Autoren mit „gutartigem“ Inhalt in ihre Malware injizieren, würde das monotone KI-Modell von Windows Defender weiterhin die Probe abfangen und Benutzer vor Schaden schützen.

In meinem Kurs „Machine Learning for Red Team Hackers“ lehre ich verschiedene Techniken, um ML-basierte Malware-Klassifikatoren zu umgehen. Eine der Techniken besteht darin, ein bösartiges Sample mit „gutartigen“ Inhalten/Funktionen zu füllen, um naiven ML-Modellen auszuweichen. Monotone Modelle sind gegen diesen Angriff resistent und zwingen böswillige Akteure dazu, viel härter zu arbeiten, wenn sie überhaupt Hoffnung haben sollen, dem Klassifikator auszuweichen.

Anwendungsfall Nr. 2: Inhaltsfilterung

Angenommen, ein Team erstellt einen Inhaltsfilter für das Surfen im Internet für Schulbibliotheken. Ein monotones KI-Modell ist hier ein großartiger Kandidat, da ein Forum mit unangemessenen Inhalten möglicherweise auch viele akzeptable Inhalte enthält.

Ein naiver Klassifikator könnte das Vorhandensein „angemessener“ Merkmale gegen das Vorhandensein „unangemessener“ Merkmale abwägen. Aber das geht nicht, da wir nicht wollen, dass unsere Kinder auf unangemessene Inhalte zugreifen, selbst wenn diese nur einen kleinen Bruchteil der Inhalte ausmachen.

Anwendungsfall Nr. 3: Selbstfahrende Auto-KI

Stellen Sie sich vor, Sie konstruieren einen Algorithmus für selbstfahrende Autos. Es schaut auf ein Bild und sieht ein grünes Licht. Es sieht auch einen Fußgänger. Sollte es das Signal von jedem gegeneinander abwägen? Absolut nicht. Die Anwesenheit eines Fußgängers reicht aus, um die Entscheidung zu treffen, das Auto anzuhalten. Die Anwesenheit von Fußgängern sollte als monotones Merkmal betrachtet werden, und in diesem Szenario sollte ein monotones KI-Modell verwendet werden.

Anwendungsfall Nr. 4: Empfehlungsmaschinen

Empfehlungsmaschinen sind ein großartiger Anwendungsfall für monotone KI-Modelle. Im Allgemeinen haben sie möglicherweise viele Eingaben zu jedem Produkt: Sternebewertung, Preis, Anzahl der Rezensionen usw. Wenn alle anderen Eingaben gleich sind, wie z. B. Sternebewertungen und Preis, würden wir das Produkt mit einer höheren Anzahl von Rezensionen bevorzugen. Wir können eine solche Logik mit einem monotonen KI-Modell durchsetzen.

Anwendungsfall Nr. 5: Spam- und Phishing-Filterung

Dieser Anwendungsfall ähnelt dem Anwendungsfall der Malware-Erkennung. Böswillige Benutzer können ihre Spam- oder Phishing-E-Mails mit harmlos erscheinenden Begriffen injizieren, um Spam-Filter zu täuschen. Ein monotones KI-Modell wird dagegen immun sein.

Implementierung und Demonstration

Wenn es um frei verfügbare Implementierungen monotoner KI-Modelle geht, stechen drei als am besten unterstützt hervor: XGBoost, LightGBM und TensorFlow Lattice.

Monotones ML XGBoost-Tutorial

XGBoost gilt als einer der leistungsstärksten Algorithmen für strukturierte Daten, basierend auf jahrelanger empirischer Forschung und Wettbewerb. Darüber hinaus wurde in XGBoost Monotonie implementiert.

Das folgende Demonstrations-XGBoost-Tutorial zur Verwendung monotoner ML-Modelle enthält ein begleitendes Python-Repository.

Beginnen Sie mit dem Import einiger Bibliotheken:

 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)

Das Szenario, das wir modellieren werden, ist eine Inhaltsfilterung oder eine Malware-Datenbank. Wir werden einige benign_features haben, die z. B. die Menge an Inhalten in Bezug auf „Wissenschaft“, „Geschichte“ und „Sport“ oder im Malware-Fall „Code-Signierung“ und „anerkannte Autoren“ modellieren.

Außerdem werden wir malicious_features haben, die z. B. die Menge an Inhalten im Zusammenhang mit „Gewalt“ und „Drogen“ oder im Malware-Fall „die Anzahl der Aufrufe von Kryptobibliotheken“ und „ein numerisches Maß für Ähnlichkeit mit einer bekannten Malware-Familie.“

Wir werden die Situation über ein generatives Modell modellieren. Wir generieren eine große Anzahl von Datenpunkten nach dem Zufallsprinzip, etwa halb gutartig und halb bösartig, mit der Funktion:

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

Jeder Datenpunkt generiert zufällig seine Merkmale. Ein „gutartiger“ Datenpunkt weist eine höhere Tendenz zu den gutartigen Merkmalen auf, während ein „bösartiger“ Datenpunkt eine stärkere Tendenz zu den bösartigen Merkmalen aufweist.

Wir verwenden eine Dreiecksverteilung wie folgt:

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

Wir verwenden diese Funktion, um die obige Logik zu erfassen:

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

Dann werden wir mit der Erstellung unseres Datensatzes fortfahren:

 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 enthält die Vektoren der zufällig generierten Merkmale, während y die Beschriftungen enthält. Dieses Klassifizierungsproblem ist nicht trivial.

Sie können sehen, dass gutartige Samples im Allgemeinen in den ersten paar Features ein größeres Gewicht haben, während bösartige Samples im Allgemeinen in den letzten paar Features ein größeres Gewicht haben.

Wenn die Daten bereit sind, führen wir eine einfache Trainings-Test-Aufteilung durch:

 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)

Wir verwenden eine Funktion, um die Daten für die Verwendung mit unserem XGBoost-Tutorial vorzubereiten:

 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)

Lassen Sie uns nun ein einfaches (nicht monotones) XGBoost-Modell mit den Daten trainieren und testen. Anschließend drucken wir die Konfusionsmatrix aus, um eine numerische Aufschlüsselung der korrekt gekennzeichneten Positivbeispiele, korrekt gekennzeichneten Negativbeispiele, falsch gekennzeichneten Positivbeispiele und falsch gekennzeichneten Negativbeispiele zu sehen.

 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) 

Wenn wir uns die Ergebnisse ansehen, können wir sehen, dass es keine signifikante Überanpassung gibt. Wir werden diese Ergebnisse mit denen der monotonen Modelle vergleichen.

Lassen Sie uns zu diesem Zweck ein monotones XGBoost-Modell trainieren und testen. Die Syntax, in der wir die monotonen Beschränkungen übergeben, ist eine Sequenz ( f ₀ , f ₁ , …, f _N ), wobei jedes f _i eines von –1, 0 oder 1 ist, je nachdem, ob das Merkmal i monoton sein soll fallend, unbeschränkt bzw. monoton steigend. Im vorliegenden Fall spezifizieren wir die schädlichen Merkmale als monoton ansteigend.

 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) 

Es ist klar, dass die Leistung des monotonen Modells dieselbe ist wie die des uneingeschränkten Modells.

Jetzt werden wir einen kontradiktorischen Datensatz erstellen. Wir werden alle bösartigen Proben nehmen und ihre gutartigen Merkmale „stopfen“, indem wir sie alle auf 1 setzen. Wir werden dann sehen, wie sich die beiden Modelle Seite an Seite verhalten.

 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

Konvertieren wir diese in ein Formular, das von XGBoost aufgenommen werden soll:

 dadv = prepare_for_XGBoost(X_adversarial, y_adversarial)

Für den letzten Schritt unseres XGBoost-Tutorials testen wir die beiden Modelltypen für maschinelles Lernen:

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

Wie Sie sehen können, war das monotone KI-Modell etwa 2.500-mal robuster gegenüber gegnerischen Angriffen.

LichtGBM

Die Syntax für die Verwendung monotoner Features in LightGBM ist ähnlich.

TensorFlow-Gitter

TensorFlow Lattice ist ein weiteres Framework zur Bewältigung von Monotoniebeschränkungen und besteht aus einer Reihe vorgefertigter TensorFlow-Schätzer sowie TensorFlow-Operatoren zum Erstellen Ihrer eigenen Gittermodelle. Gitter sind mehrdimensionale interpolierte Nachschlagetabellen, dh sie sind Punkte, die gleichmäßig im Raum verteilt sind (wie ein Gitter), zusammen mit Funktionswerten an diesen Punkten. Laut dem Google AI-Blog:

„… die Werte der Nachschlagetabelle werden trainiert, um den Verlust an den Trainingsbeispielen zu minimieren, aber zusätzlich werden benachbarte Werte in der Nachschlagetabelle gezwungen, entlang gegebener Richtungen des Eingaberaums zuzunehmen, wodurch die Modellausgaben zunehmen diese Richtungen. Wichtig ist, dass die Gittermodelle glatt sind und die Vorhersagen begrenzt sind, da sie zwischen den Werten der Nachschlagetabellen interpolieren, was dazu beiträgt, falsche große oder kleine Vorhersagen in der Testzeit zu vermeiden.“

Tutorials zur Verwendung von TensorFlow Lattice finden Sie hier.

Monotone KI-Modelle und die Zukunft

Von der Verteidigung von Geräten vor böswilligen Angriffen bis hin zum Angebot logischer und hilfreicher Restaurantempfehlungen haben sich monotone KI-Modelle als großer Segen für die Gesellschaft und als wunderbares Werkzeug erwiesen, das es zu meistern gilt. Monotone Modelle sind hier, um uns in eine neue Ära der Sicherheit, Finesse und des Verständnisses von KI einzuleiten. Und deshalb sage ich: Auf die monotonen KI-Modelle, auf den Fortschritt.