LIME: lokale, interpreteerbare modelagnostische verklaringen
U past LIME toe om een beeldclassifier en een tekstclassifier uit te leggen en genereert lokale lineaire benaderingen die aangeven welke pixels of woorden de voorspelling hebben bepaald.
LIME: lokale, interpreteerbare modelagnostische verklaringen is een gratis Machine Learning Academy-les op CoddyKit. Dit is les 2 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Machine Learning Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Machine Learning Academy bevat in totaal 4 lessen.
LIME: het kernidee
LIME (Local Interpretable Model-Agnostic Explanations) legt individuele voorspellingen van elk black-boxmodel uit door het lokaal te benaderen met een eenvoudig, interpreteerbaar model. Het inzicht is dat zelfs als een neuraal netwerk of ensemble wereldwijd complex is, het gedrag ervan rond één invoer vaak goed kan worden benaderd met een lineair model. LIME is modelonafhankelijk: het werkt met elke classifier of regressor, uitsluitend via de voorspelfunctie.
Het LIME-algoritme stap voor stap
LIME voert voor elke uit te leggen voorspelling drie stappen uit: (1) Verstoor het invoervoorbeeld door veel licht gewijzigde kopieën te maken; (2) Vraag op welke voorspellingen het black-boxmodel voor alle verstoorde voorbeelden geeft; (3) Fit een gewogen lineair model waarin voorbeelden die dichter bij het origineel liggen zwaardere gewichten krijgen. De coëfficiënten van dit surrogaatmodel vormen de uitleg.
# Conceptual pseudocode for LIME
def lime_explain(instance, model, n_samples=5000):
perturbed = perturb_around(instance, n=n_samples)
predictions = model.predict_proba(perturbed)
weights = kernel(distance(perturbed, instance))
surrogate = LinearRegression()
surrogate.fit(perturbed, predictions, sample_weight=weights)
return surrogate.coef_ # these are the LIME explanationsDe bibliotheek lime installeren
Installeer het pakket lime met pip install lime. De bibliotheek biedt gespecialiseerde uitleggers voor verschillende gegevensmodaliteiten: lime.lime_tabular.LimeTabularExplainer voor gestructureerde tabelgegevens, lime.lime_text.LimeTextExplainer voor documenten en zinnen en lime.lime_image.LimeImageExplainer voor afbeeldingen. Elke uitlegger past de verstoringsstrategie aan het domein aan.
import lime
import lime.lime_tabular
import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
data = load_breast_cancer()
X_train, X_test, y_train, y_test = train_test_split(
data.data, data.target, test_size=0.2, random_state=42
)
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)LimeTabularExplainer voor tabelgegevens
Maak een LimeTabularExplainer met de trainingsgegevens om de verdelingen van kenmerken voor de verstoring te leren. Geef namen van kenmerken en klassen op en stel discretize_continuous=True in om continue kenmerken op te delen in voor mensen leesbare bereiken, zoals 'radius <= 13.1'. Hierdoor zijn de coëfficiënten van het surrogaatmodel direct leesbaar als voorwaarden in de vorm van regels.
explainer = lime.lime_tabular.LimeTabularExplainer(
X_train,
feature_names=list(data.feature_names),
class_names=list(data.target_names),
discretize_continuous=True,
mode='classification'
)
# Explain a single test instance
instance = X_test[0]
explanation = explainer.explain_instance(
instance,
model.predict_proba,
num_features=10,
num_samples=5000
)De uitleg voor tabelgegevens lezen
De uitleg bevat voorwaarden voor kenmerken en hun gewichten. Een positief gewicht betekent dat de voorwaarde de voorspelde klasse ondersteunt; een negatief gewicht betekent dat de voorwaarde deze tegenspreekt. 'worst radius <= 16.8 (weight=0.32)' betekent bijvoorbeeld dat een kleine worst radius sterk pleit voor het voorspellen van de goedaardige klasse. Roep explanation.as_list() aan om deze voorwaarden als een Python-lijst van tupels (voorwaarde, gewicht) op te halen.
# Print top features with their weights
for feature, weight in explanation.as_list():
direction = 'supports' if weight > 0 else 'contradicts'
print(f'{feature}: weight={weight:.3f} ({direction} predicted class)')
# Or display as a matplotlib bar chart
explanation.as_pyplot_figure(label=1)
import matplotlib.pyplot as plt
plt.tight_layout()
plt.savefig('lime_tabular.png', dpi=150)LimeTextExplainer voor tekstgegevens
Bij tekstclassificatie verstoort LIME de invoer door woorden willekeurig te verbergen en te bekijken hoe de voorspelling verandert. Woorden waarvan verwijdering de voorspelling aanzienlijk laat dalen, krijgen hoge positieve gewichten. Zo worden de invloedrijkste woorden voor het voorspelde label zichtbaar en kun je eenvoudig controleren of een spamfilter of sentimentclassifier op onterechte patronen berust.
from lime.lime_text import LimeTextExplainer
from sklearn.pipeline import Pipeline
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
# Toy spam pipeline
text_pipeline = Pipeline([
('tfidf', TfidfVectorizer()),
('clf', MultinomialNB())
])
reviews = ['great product fast shipping', 'buy now click here free money']
labels = [0, 1] # 0=ham, 1=spam
text_pipeline.fit(reviews, labels)
text_explainer = LimeTextExplainer(class_names=['ham', 'spam'])
exp = text_explainer.explain_instance(
'free fast money click',
text_pipeline.predict_proba,
num_features=6
)
print(exp.as_list())LimeImageExplainer voor afbeeldingen
Bij afbeeldingen verdeelt LIME de afbeelding met SLIC in superpixels (samenhangende gebieden) en maskeert het willekeurig groepen superpixels. Het lineaire surrogaatmodel bepaalt welke superpixels de voorspelling het sterkst hebben beïnvloed. Zo wordt zichtbaar of het CNN naar het gezicht van de hond of naar de grasachtergrond kijkt. Roep get_image_and_mask aan om een gemarkeerde overlay te maken.
from lime.lime_image import LimeImageExplainer
from skimage.segmentation import mark_boundaries
import numpy as np
image_explainer = LimeImageExplainer()
# Assume 'img' is a (224, 224, 3) numpy array and 'cnn_predict' wraps the model
# exp = image_explainer.explain_instance(
# img, cnn_predict, top_labels=1, hide_color=0, num_samples=1000
# )
# image, mask = exp.get_image_and_mask(
# exp.top_labels[0], positive_only=True, num_features=5
# )
# plt.imshow(mark_boundaries(image, mask))
print('Image explainer segments image into superpixels and identifies key regions.')LIME versus SHAP: belangrijkste verschillen
Zowel LIME als SHAP legt individuele voorspellingen uit, maar ze verschillen op belangrijke punten. LIME is sneller, beter aanpasbaar en werkt van nature met tekst en afbeeldingen, maar de uitleg kan per uitvoering verschillen omdat de verstoring willekeurig is. SHAP levert wiskundig consistente uitleg met het efficiëntieaxioma, maar TreeSHAP is alleen exact voor boommodellen en KernelSHAP kan traag zijn bij grote aantallen kenmerken.
# Summary comparison
comparison = {
'LIME': {
'consistency': 'Random — varies between runs',
'speed': 'Moderate (5k perturbations)',
'modalities': 'Tabular, text, image',
'axioms_satisfied': False
},
'SHAP': {
'consistency': 'Exact for TreeExplainer',
'speed': 'Fast (TreeSHAP), slow (KernelSHAP)',
'modalities': 'Tabular, text, image (DeepSHAP)',
'axioms_satisfied': True
}
}
for method, props in comparison.items():
print(method, props)Stabiliteit: num_samples verhogen
De uitleg van LIME is stochastisch, omdat deze afhankelijk is van willekeurige verstoringen. Als je num_samples verhoogt vanaf de standaardwaarde 5000, neemt de variantie af, maar zijn meer modelaanroepen nodig. Voer om de stabiliteit te testen explain_instance meerdere keren uit met dezelfde invoer en vergelijk de gewichten van de vijf belangrijkste kenmerken. Als de rangschikking sterk verschuift, verhoog je num_samples of verklein je de breedte van de omgeving via de parameter kernel_width.
import numpy as np
weights_runs = []
for seed in range(5):
np.random.seed(seed)
exp = explainer.explain_instance(
instance, model.predict_proba,
num_features=5, num_samples=5000
)
weights_runs.append(dict(exp.as_list()))
# Check variance across runs for top feature
top_feature = exp.as_list()[0][0]
vals = [run.get(top_feature, 0) for run in weights_runs]
print(f'Top feature weight std across 5 runs: {np.std(vals):.4f}')Uitleg gebruiken om modelproblemen te vinden
LIME is een krachtig hulpmiddel voor foutopsporing. Als een sentimentclassifier een beoordeling positief markeert vanwege het woord 'not' (de ontkenning die het sentiment zou moeten omkeren), laat LIME het woord 'not' zien als een sterke positieve bijdrage — en legt het zo de fout bloot. Ook kan LIME een medische classifier betrappen die op 'hospital name' vertrouwt in plaats van op klinische kenmerken, voordat deze in productie wordt genomen.
# Example: checking a suspicious prediction
suspect_text = 'I do not recommend this product at all'
exp = text_explainer.explain_instance(
suspect_text,
text_pipeline.predict_proba,
num_features=5
)
for word, weight in exp.as_list():
print(f' word={word!r:15} weight={weight:+.3f}')
# If 'not' has positive weight for positive sentiment class,
# the model has learned a spurious pattern.LIME integreren in een beoordelingsproces
Een praktische aanpak is om LIME automatisch uit te voeren voor alle voorspellingen met een hoge zekerheid maar die tegen de intuïtie ingaan: gevallen waarin het model zeer zeker is, maar het werkelijke label onjuist is, of waarin een domeinexpert het er niet mee eens is. Door deze uitleggingen samen met de voorspellingen te loggen, ontstaat een controlespoor voor naleving van regelgeving en kun je systematische vertekeningen opsporen voordat die gebruikers raken.
# Automated explanation logging for high-confidence errors
for i, (pred, true) in enumerate(zip(model.predict(X_test), y_test)):
confidence = model.predict_proba(X_test[i:i+1]).max()
if pred != true and confidence > 0.9:
exp = explainer.explain_instance(
X_test[i], model.predict_proba, num_features=5
)
print(f'Sample {i}: predicted={data.target_names[pred]}, '
f'true={data.target_names[true]}, conf={confidence:.2f}')
for feat, w in exp.as_list()[:3]:
print(f' {feat}: {w:+.3f}')Snelle controle
Test je begrip van de concepten uit deze les over Machine Learning met Python.
Samenvatting van de les
In deze les heb je geleerd dat LIME elk black-boxmodel lokaal benadert met een gewogen lineair surrogaatmodel door de invoer te verstoren en voorspellingen op te vragen, dat gespecialiseerde uitleggers tabel-, tekst- en afbeeldingsgegevens verwerken met verstoringsstrategieën die bij het domein passen en dat LIME modelproblemen en vertekeningen kan blootleggen door te laten zien welke kenmerken of woorden een specifieke voorspelling hebben bepaald. Hierna bekijken we eerlijkheidsmaatstaven om discriminerend modelgedrag te meten en te controleren.
Leer Python met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 30
- Lessen
- 120
Veelgestelde vragen
Is de les “LIME: lokale, interpreteerbare modelagnostische verklaringen” gratis?
Ja — de volledige tekst van “LIME: lokale, interpreteerbare modelagnostische verklaringen” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Machine Learning Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Machine Learning Academy bevat in totaal 4 lessen.
Wat leer ik in “LIME: lokale, interpreteerbare modelagnostische verklaringen”?
U past LIME toe om een beeldclassifier en een tekstclassifier uit te leggen en genereert lokale lineaire benaderingen die aangeven welke pixels of woorden de voorspelling hebben bepaald. Je oefent met Machine Learning Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Machine Learning Academy te beginnen?
Ervaring vooraf is niet nodig. Machine Learning Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.
Hoe lang duurt de les “LIME: lokale, interpreteerbare modelagnostische verklaringen”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Machine Learning Academy?
Ja. Elke les over Machine Learning Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- SHAP-waarden: globale en lokale feature importance
- LIME: lokale, interpreteerbare modelagnostische verklaringen
- Fairness-metrics: demographic parity en equal opportunity
- Strategieën voor biasbeperking: pre-processing, in-processing en post-processing