Modele logiki dźwiękowej i monotonicznej sztucznej inteligencji

Sztuczna inteligencja szybko staje się niesamowitym atutem, osiągając nadludzki poziom wydajności w dziedzinach takich jak rozpoznawanie obrazów, Go, a nawet poker. Wielu jest podekscytowanych przyszłością sztucznej inteligencji i ludzkości. Jednocześnie istnieje ogólne poczucie, że sztuczna inteligencja ma jedną nieznośną wadę: sztuczna inteligencja w obecnym stanie może być nieprzewidywalnie zawodna.

Klasycznym przykładem jest Jeopardy! IBM Challenge , podczas którego Watson, IBM AI, z łatwością wyczyścił tablicę, tylko po to, by ominąć „Final Jeopardy!” pytanie, które znajdowało się w kategorii miast USA : „Największe lotnisko nosi imię bohatera II wojny światowej; jest to druga co do wielkości bitwa podczas II wojny światowej”. Watson odpowiedział: „Co to jest Toronto?????” – dodatkowe znaki zapytania (i niski zakład) wskazujące na jego wątpliwości.

Więc chociaż sztuczna inteligencja ma zdolność do bajkowego działania przez długi czas – miesiące, lata, nawet dekady – zawsze istnieje ta dokuczliwa możliwość, że nagle w tajemniczy sposób popełni błąd.

Najbardziej niepokojące nas, ludzi, nie jest to, że sztuczna inteligencja popełni błąd, ale jak „nielogiczny” będzie ten błąd. W przypadku Watsona ktoś, kto nie zna odpowiedzi na to pytanie, próbowałby „logicznie” przynajmniej odgadnąć główne miasto w USA. Uważam, że jest to jeden z głównych powodów, dla których jeszcze nie przyjęliśmy publicznie autonomicznych samochodów: nawet jeśli autonomiczne samochody mogą być statystycznie bezpieczniejsze, obawiamy się, że ich sztuczna inteligencja może niespodziewanie popełnić błąd w podobnym sensie jak Watson , ale ze znacznie poważniejszymi skutkami.

Zastanawiałem się, czy odpowiedni model AI może rozwiązać ten problem? Czy właściwa sztuczna inteligencja może podejmować rozsądne decyzje w krytycznych momentach, nawet jeśli nie ma wszystkich odpowiedzi? Taka sztuczna inteligencja byłaby w stanie zmienić bieg technologii i umożliwić nam bajkowe korzyści płynące z AI…

Wierzę, że odpowiedź na te pytania brzmi: tak. Uważam, że błędów takich jak Watsona można uniknąć dzięki zastosowaniu ulepszonych, bardziej logicznie ograniczonych modeli, których wczesny prototyp nazywa się monotonicznymi modelami uczenia maszynowego . Nie wchodząc jeszcze w szczegóły, z odpowiednim monotonicznym modelem AI:

• Samojezdny samochód byłby bezpieczniejszy, ponieważ wykrycie nawet najmniejszego sygnału ludzkiego zawsze wystarczy do aktywacji protokołu bezpieczeństwa, nawet w obecności dużej ilości innego sygnału.
• Systemy uczenia maszynowego (ML) byłyby bardziej odporne na ataki przeciwnika i nieoczekiwane sytuacje.
• Wydajność ML byłaby bardziej logiczna i zrozumiała dla człowieka.

Wierzę, że przechodzimy z ery wielkiego wzrostu mocy obliczeniowej i algorytmicznej sztucznej inteligencji do ery finezji, skuteczności i zrozumienia w sztucznej inteligencji, a monotoniczne modele uczenia maszynowego są pierwszym krokiem w tej ekscytującej podróży. Modele monotoniczne sprawiają, że sztuczna inteligencja jest bardziej „logiczna”.

Uwaga redaktora: Czytelników, którzy chcą zrobić pierwszy krok w zrozumieniu podstaw ML, zachęcamy do przeczytania naszego artykułu wprowadzającego na temat ML.

Teoria monotonicznych modeli AI

Czym więc jest model monotoniczny? Mówiąc ogólnie, model monotoniczny to model ML, który ma pewien zestaw cech (cechy monotoniczne ), których wzrost zawsze prowadzi model do zwiększenia wydajności.

W prawdziwym życiu wiele par zmiennych wykazuje związki monotoniczne. Na przykład:

• Cena gazu za podróż monotonnie rośnie wraz z przejechaną odległością.
• Prawdopodobieństwo otrzymania pożyczki jest większe przy lepszym kredycie.
• Oczekiwany czas jazdy wzrasta wraz z natężeniem ruchu.
• Przychody rosną wraz ze współczynnikiem klikalności reklamy.

Chociaż te logiczne relacje są wystarczająco jasne, w przypadku modelu ML, który interpoluje przy użyciu ograniczonych danych i braku wiedzy o domenie, mogą nie być. W rzeczywistości model może je niepoprawnie interpolować, co skutkuje absurdalnymi i zwariowanymi przewidywaniami. Modele uczenia maszynowego, które przechwytują taką wiedzę, działają lepiej w praktyce (poprzez unikanie nadmiernego dopasowania), są łatwiejsze do debugowania i bardziej interpretowalne. W większości przypadków model monotoniczny powinien być używany w połączeniu ze zwykłym modelem, jako część zespołu uczniów.

Jednym z miejsc, w którym monotoniczne modele sztucznej inteligencji naprawdę błyszczą, jest odporność na przeciwnika. Modele monotoniczne to „utwardzone” modele uczenia maszynowego, co oznacza, że ​​są odporne na ataki przeciwnika. Atakujący, którzy są w stanie manipulować tylko niemonotonicznymi cechami, nie są w stanie uniknąć monotonicznego modelu AI, ponieważ nie są w stanie zmienić etykiety przykładu w odniesieniu do monotonicznego modelu AI.

Przypadki użycia monotonicznych modeli AI

Jak dotąd dyskusja ta była całkowicie teoretyczna. Omówmy kilka rzeczywistych przypadków użycia.

Przypadek użycia nr 1: Wykrywanie złośliwego oprogramowania

Jednym z najfajniejszych przypadków użycia monotonicznych modeli AI musi być ich wykorzystanie w wykrywaniu złośliwego oprogramowania. Wdrożony w ramach Windows Defender model monotoniczny jest obecny w każdym aktualnym urządzeniu z systemem Windows, cicho chroniąc użytkowników przed złośliwym oprogramowaniem.

W jednym scenariuszu autorzy złośliwego oprogramowania podszywali się pod legalne, zarejestrowane firmy, aby oszukać urzędy certyfikacji, z powodzeniem podpisując kodem swoje złośliwe oprogramowanie za pomocą zaufanych certyfikatów. Naiwny klasyfikator złośliwego oprogramowania prawdopodobnie użyje podpisywania kodu jako funkcji i wskazuje, że takie próbki są łagodne.

Ale nie jest tak w przypadku monotonicznego modelu AI programu Windows Defender, którego monotoniczne cechy to tylko cechy wskazujące na złośliwe oprogramowanie. Bez względu na to, ile autorzy złośliwego oprogramowania „łagodnej” zawartości wprowadzą do swojego złośliwego oprogramowania, monotoniczny model sztucznej inteligencji programu Windows Defender będzie nadal przechwytywał próbkę i chronił użytkowników przed uszkodzeniami.

Na moim kursie Machine Learning dla Red Team Hackers uczę kilku technik omijania klasyfikatorów złośliwego oprogramowania opartych na ML. Jedna z technik polega na wypchaniu złośliwej próbki „niegroźną” zawartością/funkcjami w celu uniknięcia naiwnych modeli ML. Modele monotoniczne są odporne na ten atak i zmuszają złośliwych aktorów do znacznie cięższej pracy, jeśli mają mieć jakąkolwiek nadzieję na uniknięcie klasyfikatora.

Przypadek użycia nr 2: filtrowanie treści

Załóżmy, że zespół opracowuje filtr treści do przeglądania stron internetowych dla bibliotek szkolnych. Monotoniczny model sztucznej inteligencji jest doskonałym kandydatem do użycia tutaj, ponieważ forum zawierające nieodpowiednie treści może również zawierać wiele akceptowalnych treści.

Naiwny klasyfikator może ważyć obecność „odpowiednich” cech z obecnością „nieodpowiednich” cech. Ale tak się nie stanie, ponieważ nie chcemy, aby nasze dzieci miały dostęp do nieodpowiednich treści, nawet jeśli stanowią one tylko niewielką część treści.

Przypadek użycia nr 3: autonomiczny samochód AI

Wyobraź sobie konstruowanie algorytmu autonomicznego samochodu. Patrzy na obraz i widzi zielone światło. Widzi też pieszego. Czy powinien ważyć sygnał między sobą? Absolutnie nie. Obecność pieszego wystarczy do podjęcia decyzji o zatrzymaniu samochodu. Obecność pieszych należy postrzegać jako cechę monotoniczną iw tym scenariuszu należy zastosować monotoniczny model sztucznej inteligencji.

Przypadek użycia nr 4: Silniki rekomendacji

Silniki rekomendacji są świetnym przypadkiem użycia dla monotonicznych modeli AI. Ogólnie rzecz biorąc, mogą mieć wiele danych wejściowych na temat każdego produktu: ocena w postaci gwiazdek, cena, liczba recenzji itp. Przy wszystkich innych danych wejściowych, takich jak ocena w postaci gwiazdek i cena, wolelibyśmy produkt, który ma większą liczbę recenzji. Możemy wymusić taką logikę za pomocą monotonicznego modelu AI.

Przypadek użycia nr 5: filtrowanie spamu i phishingu

Ten przypadek użycia jest podobny do przypadku użycia wykrywania złośliwego oprogramowania. Złośliwi użytkownicy mogą wstrzykiwać do swoich wiadomości spamowych lub phishingowych nieszkodliwe terminy, aby oszukać filtry spamu. Monotoniczny model AI będzie na to odporny.

Wdrożenie i demonstracja

Jeśli chodzi o swobodnie dostępne implementacje monotonicznych modeli AI, trzy wyróżniają się jako najlepiej obsługiwane: XGBoost, LightGBM i TensorFlow Lattice.

Samouczek Monotonic ML XGBoost

XGBoost jest uważany za jeden z najlepiej działających algorytmów na ustrukturyzowanych danych, w oparciu o lata badań empirycznych i konkurencji. Dodatkowo w XGBoost zaimplementowano monotoniczność.

Poniższy samouczek demonstracyjny XGBoost dotyczący korzystania z monotonicznych modeli ML ma towarzyszące repozytorium Pythona.

Zacznij od zaimportowania kilku bibliotek:

 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)

Scenariusz, który zamierzamy zamodelować, to filtrowanie treści lub baza danych złośliwego oprogramowania. Będziemy mieli kilka benign_features , które modelują, np. ilość treści związanych z „nauką”, „historią” i „sportem” lub, w przypadku złośliwego oprogramowania, „podpisywaniem kodu” i „uznanymi autorami”.

Ponadto będziemy mieć malicious_features , które modelują np. ilość treści związanych z „przemocą” i „narkotykami” lub w przypadku złośliwego oprogramowania „liczbę wywołań do bibliotek kryptograficznych” i „liczbową miarę podobieństwo do znanej rodziny złośliwego oprogramowania”.

Zamodelujemy sytuację za pomocą modelu generatywnego. Losowo generujemy dużą liczbę punktów danych, w połowie łagodnych, a w połowie złośliwych, korzystając z funkcji:

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

Każdy punkt danych losowo wygeneruje swoje cechy. „Łagodny” punkt danych będzie miał wyższe odchylenie dla łagodnych cech, podczas gdy „złośliwy” punkt danych będzie miał wyższe odchylenie dla złośliwych cech.

Użyjemy rozkładu trójkątnego, jak na przykład:

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

Użyjemy tej funkcji, aby uchwycić powyższą logikę:

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

Następnie przystąpimy do tworzenia naszego zbioru danych:

 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 zawiera wektory losowo generowanych obiektów, podczas gdy y zawiera etykiety. Ten problem klasyfikacji nie jest trywialny.

Widać, że próbki łagodne mają zazwyczaj większą wagę w przypadku kilku pierwszych funkcji, podczas gdy próbki złośliwe zazwyczaj mają większą wagę w przypadku kilku ostatnich funkcji.

Mając gotowe dane, przeprowadźmy prosty podział treningowo-testowy:

 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)

Użyjemy funkcji do przygotowania danych do użycia w naszym samouczku 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)

Teraz przeszkolmy i przetestujmy prosty (niemonotoniczny) model XGBoost na danych. Następnie wydrukujemy macierz pomyłek, aby zobaczyć rozkład liczbowy prawidłowo oznaczonych przykładów pozytywnych, poprawnie oznaczonych przykładów negatywnych, niepoprawnie oznaczonych przykładów pozytywnych i nieprawidłowo oznaczonych przykładów negatywnych.

 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) 

Patrząc na wyniki, widzimy, że nie ma znaczącego overfittingu. Porównamy te wyniki z wynikami modeli monotonicznych.

W tym celu wytrenujmy i przetestujmy monotoniczny model XGBoost. Składnia, w której przechodzimy przez ograniczenia monotoniczne, to ciąg ( f ₀ , f ₁ , …, f _N ), gdzie każde _fi jest jednym z -1, 0 lub 1, w zależności od tego, czy chcemy, aby cecha i była monotonicznie odpowiednio malejący, nieograniczony lub monotonicznie rosnący. W omawianym przypadku określamy, że złośliwe funkcje mają charakter monotoniczny.

 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) 

Oczywiste jest, że wydajność modelu monotonicznego jest taka sama jak modelu niezwiązanego.

Teraz stworzymy zestaw danych przeciwnika. Zamierzamy pobrać wszystkie złośliwe próbki i „umieścić” ich łagodne cechy, ustawiając je wszystkie na 1. Następnie zobaczymy, jak te dwa modele działają obok siebie.

 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

Przekształćmy je w formularz do przetworzenia przez XGBoost:

 dadv = prepare_for_XGBoost(X_adversarial, y_adversarial)

W ostatnim kroku naszego samouczka XGBoost przetestujemy dwa typy modeli uczenia maszynowego:

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

Jak widać, monotoniczny model AI był około 2500 razy bardziej odporny na ataki przeciwnika.

LightGBM

Składnia korzystania z funkcji monotonicznych w LightGBM jest podobna.

Krata TensorFlow

TensorFlow Lattice to kolejna platforma do radzenia sobie z ograniczeniami monotoniczności i jest zestawem gotowych estymatorów TensorFlow, a także operatorów TensorFlow do budowania własnych modeli sieci. Kraty to wielowymiarowe interpolowane tabele przeglądowe, co oznacza, że ​​są punktami równomiernie rozmieszczonymi w przestrzeni (jak siatka) wraz z wartościami funkcji w tych punktach. Według bloga Google AI:

„…wartości tabeli przeglądowej są szkolone w celu zminimalizowania strat na przykładach uczących, ale dodatkowo sąsiednie wartości w tabeli przeglądowej są ograniczone do wzrostu wzdłuż danych kierunków przestrzeni wejściowej, co powoduje wzrost wyników modelu w te kierunki. Co ważne, ponieważ interpolują one wartości z tabeli przeglądowej, modele kratowe są gładkie, a predykcje ograniczone, co pomaga uniknąć fałszywych dużych lub małych prognoz w czasie testowania”.

Samouczki dotyczące korzystania z sieci TensorFlow Lattice można znaleźć tutaj.

Monotoniczne modele AI i przyszłość

Od ochrony urządzeń przed złośliwymi atakami po oferowanie logicznych i pomocnych rekomendacji restauracji, monotoniczne modele sztucznej inteligencji okazały się wielkim dobrodziejstwem dla społeczeństwa i wspaniałym narzędziem do opanowania. Modele monotoniczne są tutaj, aby wprowadzić nas w nową erę bezpieczeństwa, finezji i zrozumienia w sztucznej inteligencji. A więc mówię, za monotoniczne modele AI, za postęp.