26.1.4. Modell-extrakció (Model Extraction) technikák

Mi történik, ha a támadó célja nem a modell megbénítása, megtévesztése vagy mérgezése, hanem annak egyszerű lemásolása? A modell-extrakció, vagy más néven modell-lopás (model stealing) pont erre irányul: egy fekete dobozként kezelt, távoli modell funkcionalitásának vagy belső logikájának replikálása anélkül, hogy a támadó hozzáférne az eredeti modell architektúrájához, paramétereihez vagy tanító adathalmazához.

Ez a támadás az egyik legközvetlenebb módja a szellemi tulajdon ellopásának az MI területén. Egy sikeres extrakcióval a támadó létrehoz egy „szurrogát” modellt, amit aztán ingyen használhat, továbbfejleszthet, vagy ami még rosszabb: offline módon, korlátlan lekérdezési lehetőséggel elemezhet sebezhetőségek után kutatva.

Az extrakció alapelve: A fekete doboz feltörése

A támadás alapfeltételezése, hogy a támadó rendelkezik lekérdezési hozzáféréssel a célmodellhez, tipikusan egy API-n keresztül. A folyamat lényege, hogy a támadó szisztematikusan küld bemeneteket a modellnek, megfigyeli a kimeneteket (predikciókat, valószínűségi eloszlásokat), és ezt a bemenet-kimenet párokból álló adathalmazt használja fel egy saját, helyi modell betanítására.

Extrakciós stratégiák és implementációk

Két fő irányt különböztetünk meg aszerint, hogy a támadó mit szeretne pontosan lemásolni: a modell döntési határait vagy a kimeneti valószínűségeit.

Funkcionalitás-extrakció (Equation Solving)

Itt a cél a modell döntési logikájának replikálása. A támadó nem a kimeneti valószínűségek finom részleteire kíváncsi, hanem arra, hogy egy adott bemenet melyik kategóriába esik. Ez különösen hatékony egyszerűbb modellek (pl. logisztikus regresszió, SVM, döntési fák) ellen.

A folyamat lényege, hogy a támadó szintetikus adatokat generál, lekérdezi a célmodellt a címkékért, majd egy egyszerűbb „tanuló” modellt illeszt erre a mesterségesen létrehozott adathalmazra.

# Python példa scikit-learn használatával
import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification

# 1. Szimulálunk egy "fekete doboz" célmodellt
target_model = LogisticRegression().fit(*make_classification(n_samples=1000, n_features=20, n_informative=5, n_redundant=0, random_state=42))

def query_black_box(data):
 # A valóságban ez egy API hívás lenne (pl. requests.post)
 return target_model.predict(data)

# 2. Támadó: szintetikus adatokat generálunk
num_queries = 500
synthetic_data = np.random.rand(num_queries, 20) * 10 - 5

# 3. Lekérdezzük a célmodellt a címkékért
synthetic_labels = query_black_box(synthetic_data)

# 4. Betanítunk egy saját, szurrogát modellt a megszerzett adatokon
surrogate_model = LogisticRegression()
surrogate_model.fit(synthetic_data, synthetic_labels)

# Az extrahált modellünk készen áll a használatra
print(f"Szurrogát modell pontossága (teszt adaton): {surrogate_model.score(*make_classification(random_state=1)[:2]):.2f}")

Hűség-extrakció (Fidelity Extraction)

Ez egy jóval ambiciózusabb cél. A támadó nem csupán a döntési határokat, hanem a célmodell kimeneti valószínűségi eloszlását (a „soft” címkéket vagy logitokat) akarja lemásolni. Egy magas hűségű szurrogát modell szinte megkülönböztethetetlenül viselkedik az eredetitől, ami elengedhetetlen például a transzferálható adverzárius támadások generálásához.

A megközelítés hasonló, de a tanuló modell tanításakor nem a „hard” címkéket, hanem a valószínűségeket használjuk, és a veszteségfüggvényt is ehhez igazítjuk (pl. Kullback-Leibler divergencia vagy Mean Squared Error).

# Pszeudokód / Koncepcionális PyTorch példa
import torch
import torch.nn as nn
import torch.optim as optim

# Tegyük fel, hogy a 'query_black_box_probs' a valószínűségeket adja vissza
def query_black_box_probs(data):
 # API hívás, ami pl. egy JSON-t ad vissza: {'class_A': 0.9, 'class_B': 0.1}
 return target_model.predict_proba(data)

# A támadó saját neurális hálója (szurrogát modell)
surrogate_nn = nn.Sequential(nn.Linear(20, 10), nn.ReLU(), nn.Linear(10, 2), nn.Softmax(dim=1))
optimizer = optim.Adam(surrogate_nn.parameters(), lr=0.01)
# A veszteségfüggvény a kimeneti eloszlások különbségét méri
loss_fn = nn.MSELoss() 

for _ in range(num_epochs):
 synthetic_data = torch.randn(64, 20)
 # Célmodell valószínűségei (ezek a "címkék")
 target_probs = torch.tensor(query_black_box_probs(synthetic_data.numpy())).float()
 
 # Szurrogát modell tanítása
 surrogate_probs = surrogate_nn(synthetic_data)
 loss = loss_fn(surrogate_probs, target_probs)
 
 optimizer.zero_grad()
 loss.backward()
 optimizer.step()

Összefoglalva, a modell-extrakció egy komoly fenyegetést jelent, amely közvetlenül célozza a fejlesztésbe fektetett szellemi tulajdont. Bár a védekezés nem triviális, a lekérdezések monitorozása és a kimenetek finom módosítása hatékonyan csökkentheti a támadás sikerességének esélyét.