AnalysisOOD.py

import torch
import torchvision.models as models
from PIL import Image, ImageStat
from torch import nn, relu
import numpy as np
import matplotlib.image as mpimg
import matplotlib.pyplot as plt
import pandas as pd
from pathlib import Path
import seaborn as sns
import logging
import lightgbm as lgb
import shap
import os
import math
import cv2
from skimage import color
from skimage.filters import sobel
from sklearn.decomposition import PCA
from sklearn.model_selection import train_test_split
from sklearn.inspection import permutation_importance
from sklearn.metrics import roc_auc_score
import hoggorm as ho
from hyppo.independence import Hsic
from collections import Counter
from scipy import stats
from mpl_toolkits.axes_grid1 import ImageGrid
from joblib import Parallel, delayed

# ---------------------- CONFIG ----------------------
DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
OOD_ASSIGNED_ORIGINAL = pd.read_csv(Path(__file__).parent / 'BoatDataset.csv')
logging.basicConfig(
    level=logging.INFO,
    format='%(name)s - %(levelname)s:\n%(message)s\n',
    handlers=[logging.StreamHandler()]
)
LOGGER = logging.getLogger("Outliers Analysis Logger")
humanArtArtstyles = ['art_nouveau', 'baroque', 'expressionism', 'impressionism', 'post_impressionism', 'realism', 'renaissance', 'romanticism', 'surrealism', 'ukiyo_e']
AI_SDArtArtstyles = ['AI_SD_art_nouveau', 'AI_SD_baroque', 'AI_SD_expressionism', 'AI_SD_impressionism', 'AI_SD_post_impressionism', 'AI_SD_realism', 'AI_SD_renaissance', 'AI_SD_romanticism', 'AI_SD_surrealism', 'AI_SD_ukiyo-e']
AI_LDArtArtstyles = ['AI_LD_art_nouveau', 'AI_LD_baroque', 'AI_LD_expressionism', 'AI_LD_impressionism', 'AI_LD_post_impressionism', 'AI_LD_realism', 'AI_LD_renaissance', 'AI_LD_romanticism', 'AI_LD_surrealism', 'AI_LD_ukiyo-e']


plt.style.use('seaborn-v0_8')
sns.set_theme(style="whitegrid")

# ---------------------- HELPER FUNCTIONS ----------------------
def Z_ScoreOutliers(data, paths) -> dict:
    mean = np.mean(data)
    std = np.std(data)

    threshold = 2.5
    outliers = {}
    for x, path in zip(data, paths):
        z_score = (x - mean) / std
        if abs(z_score) > threshold:
            outliers[path] = x
    
    return outliers

def ExtractArtStyle(imagePath: str) -> str:
    return imagePath.split('/')[2]

def SortByArtStyle(series, order_list):
    return series.map({v: i for i, v in enumerate(order_list)})

def AnovaEffectSizeOmegaSquared(*groups):
    """
    Compute eta-squared and omega-squared for one-way ANOVA.
    Input: groups as arrays/lists (e.g. human, ai_sd, ai_ld)
    """
    # Flatten all groups into one array
    all_data = np.concatenate(groups)
    grand_mean = np.mean(all_data)

    # Number of groups and total N
    k = len(groups)
    N = len(all_data)

    # Between-group sum of squares
    ss_between = sum(len(g) * (np.mean(g) - grand_mean) ** 2 for g in groups)

    # Within-group sum of squares
    ss_within = sum(((g - np.mean(g)) ** 2).sum() for g in groups)

    # Total sum of squares
    ss_total = ss_between + ss_within

    # Degrees of freedom
    df_between = k - 1
    df_within = N - k

    # Mean square within
    ms_within = ss_within / df_within

    # Omega squared
    omega_sq = (ss_between - (df_between * ms_within)) / (ss_total + ms_within)

    return omega_sq

def FastImageBasicStats(path, size=256):
    img = cv2.imread(path)
    if img is None:
        return dict(brightness=np.nan, colorfulness=np.nan, saturation=np.nan,
                    contrast=np.nan, entropy=np.nan, edge_density=np.nan,
                    aspect_ratio=np.nan, num_pixels=np.nan)

    # resize for speed
    img = cv2.resize(img, (size, size), interpolation=cv2.INTER_AREA)
    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB).astype(np.float32) / 255.0
    h, w = img.shape[:2]

    # brightness ≈ mean grayscale
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    if gray.dtype != np.uint8:
        gray = gray.astype(np.uint8)

    brightness = float(gray.mean())

    # contrast = std of grayscale
    contrast = float(gray.std())

    # saturation (mean of HSV S channel)
    hsv = cv2.cvtColor((img*255).astype(np.uint8), cv2.COLOR_RGB2HSV)
    saturation = float(hsv[...,1].mean() / 255.0)

    # colorfulness (simplified Hasler & Suesstrunk)
    rg = img[...,0] - img[...,1]
    yb = 0.5*(img[...,0] + img[...,1]) - img[...,2]
    colorfulness = float(np.sqrt(np.mean(rg**2)) + 0.3*np.sqrt(np.mean(yb**2)))

    # entropy (use cv2 calcHist instead of numpy.histogram for speed)
    hist = cv2.calcHist([gray.astype(np.float32)], [0], None, [256], [0,1])
    probs = hist.flatten() / hist.sum()
    entropy = float(-(probs * np.log2(probs + 1e-12)).sum())

    # edge density (Sobel with OpenCV instead of skimage.sobel)
    edges = cv2.Sobel(gray, cv2.CV_32F, 1, 1, ksize=3)
    edge_density = float((edges > 0.1).sum() / edges.size)

    aspect_ratio = float(w / h)
    num_pixels = h * w

    return dict(brightness=brightness, colorfulness=colorfulness, saturation=saturation,
                contrast=contrast, entropy=entropy, edge_density=edge_density,
                aspect_ratio=aspect_ratio, num_pixels=num_pixels)


def EnrichWithStatsParallel(df, n_jobs=-1):
    stats_list = Parallel(n_jobs=n_jobs, backend="multiprocessing")(
        delayed(FastImageBasicStats)(p) for p in df['image_path'].tolist()
    )
    stats_df = pd.DataFrame(stats_list)
    return pd.concat([df.reset_index(drop=True), stats_df], axis=1)

# ---------------------- BASIC ANALYSIS ----------------------
AI_LD = OOD_ASSIGNED_ORIGINAL[OOD_ASSIGNED_ORIGINAL.source=="AI_LD"]
AI_SD = OOD_ASSIGNED_ORIGINAL[OOD_ASSIGNED_ORIGINAL.source=="AI_SD"]
human = OOD_ASSIGNED_ORIGINAL[OOD_ASSIGNED_ORIGINAL.source=="human"]

human = human.copy()
AI_SD = AI_SD.copy()
AI_LD = AI_LD.copy()

AI_LD['art_style'] = AI_LD['image_path'].apply(ExtractArtStyle)
AI_SD['art_style'] = AI_SD['image_path'].apply(ExtractArtStyle)
human['art_style'] = human['image_path'].apply(ExtractArtStyle)

AI_LD = AI_LD.sort_values(by='art_style', 
                         key=lambda x: SortByArtStyle(x, AI_LDArtArtstyles))
AI_SD = AI_SD.sort_values(by='art_style',
                         key=lambda x: SortByArtStyle(x, AI_SDArtArtstyles))
human = human.sort_values(by='art_style',
                         key=lambda x: SortByArtStyle(x, humanArtArtstyles))

AI_LD = AI_LD.drop(columns=['art_style'])
AI_SD = AI_SD.drop(columns=['art_style'])
human = human.drop(columns=['art_style'])

dfAILD = AI_LD
nTotalLD = len(dfAILD)
nUniqueLD = len(dfAILD.drop_duplicates())

if nTotalLD == nUniqueLD:
    print("✅ All rows are unique")
else:
    print(f"⚠️ {nTotalLD - nUniqueLD} duplicate rows found")

dfAISD = AI_SD
nTotalSD = len(dfAISD)
nUniqueSD = len(dfAISD.drop_duplicates())

if nTotalSD == nUniqueSD:
    print("✅ All rows are unique")
else:
    print(f"⚠️ {nTotalSD - nUniqueSD} duplicate rows found")

dfHuman = human
nTotalHum = len(dfHuman)
nUniqueHum = len(dfHuman.drop_duplicates())

sources = ['human', 'AI_SD', 'AI_LD']
nTotalList = [nTotalHum, nTotalSD, nTotalLD]
nUniqueList = [nUniqueHum, nUniqueSD, nUniqueLD]

if nTotalHum == nUniqueHum:
    print("✅ All rows are unique")
else:
    print(f"⚠️ {nTotalHum - nUniqueHum} duplicate rows found")

humanArtImagePaths = human["image_path"].tolist()
humanArtOODIDdfs = [human[human["classification"] == 'OOD'], human[human["classification"] == 'ID']]

AI_SDArtImagePaths = AI_SD["image_path"].tolist()
AI_SDArtOODIDdfs = [AI_SD[AI_SD["classification"] == 'OOD'], AI_SD[AI_SD["classification"] == 'ID']]

AI_LDArtImagePaths = AI_LD["image_path"].tolist()
AI_LDArtOODIDdfs = [AI_LD[AI_LD["classification"] == 'OOD'], AI_LD[AI_LD["classification"] == 'ID']]

OODsDFs = [humanArtOODIDdfs[0], AI_SDArtOODIDdfs[0], AI_LDArtOODIDdfs[0]]

# ---------------------- VISUALIZATIONS OF BASIC ANALYSIS ----------------------
plotsPath = Path(__file__).parent / 'plots'
os.makedirs(plotsPath, exist_ok=True)

# Set up the color palette
colors = {'human': '#1f77b4', 'AI_SD': '#ff7f0e', 'AI_LD': '#2ca02c'}

barWidth = 0.3
groupSpacing = 0.4
fig = plt.subplots(figsize =(22, 11)) 

br1 = np.arange(len(nUniqueList)) * (barWidth * 3 + groupSpacing) 
br2 = [x + barWidth for x in br1] 

plt.bar(br1, nTotalList, color =colors['human'], width = barWidth, 
        edgecolor ='red', label ='Total values', linewidth=2) 
plt.bar(br2, nUniqueList, color =colors['AI_LD'], width = barWidth, 
        edgecolor ='red', label ='Unique values', linewidth=2) 

plt.title("OOD Dataset uniqueness by total samples sizes and unique samples sizes", fontweight='bold', fontsize=28)
plt.xlabel('Sources', fontweight ='bold', fontsize = 25) 
plt.ylabel('Samples', fontweight ='bold', fontsize = 25) 
plt.xticks([r + barWidth / 2 for r in br1], sources, fontsize = 13)
plt.yticks(fontsize = 16)
plt.legend()
plt.savefig(plotsPath / ("OOD-ID_" + "DatasetCompleteness.png"), dpi=300)
plt.close()

fig = plt.subplots(figsize =(28, 14))
plt.scatter(['OOD', 'ID'], OOD_ASSIGNED_ORIGINAL.iloc[:, 0:2].isna().sum(axis = 0))
plt.xlabel('Sources', fontweight ='bold', fontsize = 25) 
plt.ylabel('Missing values', fontweight ='bold', fontsize = 25)
plt.xticks(fontsize = 13)
plt.yticks(fontsize = 16)
plt.title("OOD Dataset completeness by missing values", fontweight='bold', fontsize=28)
plt.savefig(plotsPath / 'OOD-ID_MissingValues.png', dpi=300)
plt.close()

# --- Data Analysis: OOD to ID samples distribution --- 
fig, axes = plt.subplots(3, 1, figsize=(10, 14))

axes[0].set_title("Human art: OOD vs ID samples quantity", fontweight='bold', fontsize=13)
counts = [len(s["classification"].tolist()) for s in humanArtOODIDdfs]
centers = np.arange(2)

axes[0].bar(
    centers, counts, color=colors['human'],
    width=0.25, edgecolor='red', linewidth=3, align="center"
)     

axes[0].set_ylim(0, max(counts) + (max(counts) / 10))
axes[0].set_xticks(centers)
axes[0].set_xticklabels(['OOD', 'ID'], fontsize=10)
axes[0].set_xlabel("Classification", fontweight='bold', fontsize=12)
axes[0].set_ylabel("Occurences", fontweight='bold', fontsize=12)


axes[1].set_title("AI_SD art: OOD vs ID samples quantity", fontweight='bold', fontsize=13)
counts = [len(s["classification"].tolist()) for s in AI_SDArtOODIDdfs]
centers = np.arange(2)

axes[1].bar(
    centers, counts, color=colors['AI_SD'],
    width=0.25, edgecolor='red', linewidth=3, align="center"
)        

axes[1].set_ylim(0, max(counts) + (max(counts) / 10))
axes[1].set_xticks(centers)
axes[1].set_xticklabels(['OOD', 'ID'], fontsize=10)   
axes[1].set_xlabel("Classification", fontweight='bold', fontsize=12)
axes[1].set_ylabel("Occurences", fontweight='bold', fontsize=12)


axes[2].set_title("AI_LD art: OOD vs ID samples quantity", fontweight='bold', fontsize=13)
counts = [len(s["classification"].tolist()) for s in AI_LDArtOODIDdfs]
centers = np.arange(2)

axes[2].bar(
    centers, counts, color=colors['AI_LD'],
    width=0.25, edgecolor='red', linewidth=3, align="center"
)    

axes[2].set_ylim(0, max(counts) + (max(counts) / 10))
axes[2].set_xticks(centers)
axes[2].set_xticklabels(['OOD', 'ID'], fontsize=10)   
axes[2].set_xlabel("Classification", fontweight='bold', fontsize=12)
axes[2].set_ylabel("Occurences", fontweight='bold', fontsize=12)

for ax in axes:
    ax.set_xlabel("Classification", fontweight='bold', fontsize=14)
    ax.set_ylabel("Occurrences", fontweight='bold', fontsize=14)

plt.tight_layout()
plt.savefig(plotsPath / ("OOD-ID_DistributionsHistograms.png"), dpi=300)
plt.close()

# --- Data Analysis: OOD artstyles classification --- 
for i, OODlist in enumerate(OODsDFs):
    fig, axes = plt.subplots(3, 1, figsize=(10, 14))
    plt.subplots_adjust(left=0.13, right=0.92, bottom=0.10, top=0.94, hspace=0.8)
    # axes[0] art styles distribution
    axes[0].set_title(f"{sources[i]} art: OOD samples artstyles distribution", fontweight='bold', fontsize=13)
    Artstyles = [ExtractArtStyle(img) for img in OODlist["image_path"]]
    unique_artstyles = list(dict.fromkeys(Artstyles))

    cnt = Counter(Artstyles)
    counts = [cnt.get(s, 0) for s in unique_artstyles]

    centers = np.arange(len(unique_artstyles))

    axes[0].bar(
        centers, counts, color=colors['human'],
        width=0.25, edgecolor='red', linewidth=2, align="center"
    )     

    axes[0].set_ylim(0, max(counts) + (max(counts) / 10))
    axes[0].set_xticks(centers)
    axes[0].set_xticklabels(unique_artstyles, fontsize=10, rotation=45)
    axes[0].set_xlabel("Artstyle", fontweight='bold', fontsize=12)
    axes[0].set_ylabel("Occurences", fontweight='bold', fontsize=12)

    # axes[1] most frequent artstyle 3 images samples in red border
    axes[1].set_title(f"{sources[i]} art: 3 OOD samples of the {unique_artstyles[counts.index(max(counts))]} artstyle", fontweight='bold', fontsize=13)
    samplesPaths1 = np.random.choice(OODlist["image_path"][OODlist["image_path"].apply(ExtractArtStyle) == unique_artstyles[counts.index(max(counts))]], 3)
    grid1 = ImageGrid(fig, axes[1].get_subplotspec(),  
                 nrows_ncols=(1, 3),  
                 axes_pad=0.1,  
                 )

    for ax, im in zip(grid1, samplesPaths1):
        ax.imshow(mpimg.imread(im))
    
    axes[1].axes.get_xaxis().set_visible(False)
    axes[1].axes.get_yaxis().set_visible(False)
    axes[1].grid(False)
    
    axes[2].axes.get_xaxis().set_visible(False)
    axes[2].axes.get_yaxis().set_visible(False)
    axes[2].grid(False)

    unique_artstyles.remove(unique_artstyles[counts.index(max(counts))])
    counts.remove(max(counts))
    axes[2].set_title(f"{sources[i]} art: 3 OOD samples of the {unique_artstyles[counts.index(max(counts))]} artstyle", fontweight='bold', fontsize=13)
    samplesPaths2 = np.random.choice(OODlist["image_path"][OODlist["image_path"].apply(ExtractArtStyle) == unique_artstyles[counts.index(max(counts))]], 3)
    grid2 = ImageGrid(fig, axes[2].get_subplotspec(),  
                 nrows_ncols=(1, 3),  
                 axes_pad=0.1,  
                 )

    for ax, im in zip(grid2, samplesPaths2):
        ax.imshow(mpimg.imread(im))

    axes[2].axes.get_xaxis().set_visible(False)
    axes[2].axes.get_yaxis().set_visible(False)

    for ax in axes:
        ax.set_xlabel("Artstyle", fontweight='bold', fontsize=14)
        ax.set_ylabel("Occurrences", fontweight='bold', fontsize=14)

    plt.savefig(plotsPath / (f"{sources[i].capitalize()}-OOD-ID_DistributionsHistograms.png"), dpi=300)
    plt.close()

# --- Advanced Data Analysis: Deep analysis with embeddings, PCA, Classifier + AUC and SHAP ---
humanStats = pd.read_parquet("CodeOOD/human_stats.parquet")
AI_SDStats = pd.read_parquet("CodeOOD/AI_SD_stats.parquet")
AI_LDStats = pd.read_parquet("CodeOOD/AI_LD_stats.parquet")

embH = np.load("CodeOOD/emb_h.npy", mmap_mode=None)
embSD = np.load("CodeOOD/emb_sd.npy", mmap_mode=None)
embLD = np.load("CodeOOD/emb_ld.npy", mmap_mode=None)

pca = PCA(n_components=128, random_state=42)
pca.fit(np.vstack([embH, embSD, embLD]))

humanEmbeddings128dim = pca.transform(embH)
AI_SDEmbeddings128dim = pca.transform(embSD)
AI_LDEmbeddings128dim = pca.transform(embLD)

statsColsNames = ['brightness','colorfulness','saturation','contrast','entropy','edge_density','aspect_ratio','num_pixels']
def BuildPCAStatsMatrix(df_stats: pd.DataFrame, embeddings_reduced):
    stats = df_stats[statsColsNames].fillna(df_stats[statsColsNames].mean()).values
    X = np.hstack([embeddings_reduced, stats])
    return X

featureMatrixHuman = BuildPCAStatsMatrix(humanStats, humanEmbeddings128dim)
featureMatrixHumanLabels = (humanStats["classification"] == 'OOD').astype(int).values
featureMatrixAI_SD = BuildPCAStatsMatrix(AI_SDStats, AI_SDEmbeddings128dim)
featureMatrixAI_SDLabels = (AI_SDStats["classification"] == 'OOD').astype(int).values
featureMatrixAI_LD = BuildPCAStatsMatrix(AI_LDStats, AI_LDEmbeddings128dim)
featureMatrixAI_LDLabels = (AI_LDStats["classification"] == 'OOD').astype(int).values

principalComponentNames = [f"PC{i+1}" for i in range(humanEmbeddings128dim.shape[1])]
featureNames = principalComponentNames + statsColsNames

X_trainHuman, X_testHuman, y_trainHuman, y_testHuman = train_test_split(featureMatrixHuman, featureMatrixHumanLabels, stratify=featureMatrixHumanLabels, test_size=0.2, random_state=42)
X_trainAI_SD, X_testAI_SD, y_trainAI_SD, y_testAI_SD = train_test_split(featureMatrixAI_SD, featureMatrixAI_SDLabels, stratify=featureMatrixAI_SDLabels, test_size=0.2, random_state=42)
X_trainAI_LD, X_testAI_LD, y_trainAI_LD, y_testAI_LD = train_test_split(featureMatrixAI_LD, featureMatrixAI_LDLabels, stratify=featureMatrixAI_LDLabels, test_size=0.2, random_state=42)

X_trainHuman = pd.DataFrame(X_trainHuman, columns=featureNames)
X_testHuman  = pd.DataFrame(X_testHuman, columns=featureNames)

X_trainAI_SD = pd.DataFrame(X_trainAI_SD, columns=featureNames)
X_testAI_SD  = pd.DataFrame(X_testAI_SD, columns=featureNames)

X_trainAI_LD = pd.DataFrame(X_trainAI_LD, columns=featureNames)
X_testAI_LD  = pd.DataFrame(X_testAI_LD, columns=featureNames)

clf = lgb.LGBMClassifier(n_estimators=2000, learning_rate=0.05)


# Human classification
clf.fit(X_trainHuman, y_trainHuman, eval_set=[(X_testHuman, y_testHuman)], eval_metric='auc')
pred = clf.predict_proba(X_testHuman)[:,1]
auc = roc_auc_score(y_testHuman, pred)
print("Human OOD AUC:", auc)

fi = pd.DataFrame({
    'feature': featureNames,
    'importance': clf.feature_importances_
}).sort_values('importance', ascending=False).reset_index(drop=True)
print(fi.head(20))

perm = permutation_importance(clf, X_testHuman, y_testHuman, n_repeats=10, random_state=42, scoring='roc_auc')
perm_df = pd.DataFrame({'feature': featureNames, 'perm_mean': perm.importances_mean, 'perm_std': perm.importances_std})
perm_df = perm_df.sort_values('perm_mean', ascending=False).reset_index(drop=True)
print(perm_df.head(20))

explainer = shap.TreeExplainer(clf)
shap_vals = explainer.shap_values(X_testHuman)  # for binary, this returns a list [class0, class1]
if isinstance(shap_vals, list) and len(shap_vals) == 2:
    shap_vals_pos = shap_vals[1]
else:
    shap_vals_pos = shap_vals
X_test_df = pd.DataFrame(X_testHuman, columns=featureNames)
shap.summary_plot(shap_vals_pos, X_test_df, feature_names=featureNames, plot_type="bar", show=False)
plt.title("Human Art: Component importance in OOD-ID classification bar plot")
plt.show()
plt.close()
shap.summary_plot(shap_vals_pos, X_test_df, feature_names=featureNames, plot_type="dot", show=False)
plt.title("Human Art: Component importance in OOD-ID classification dot plot")
plt.show()
plt.close()

# AI_SD classification
clf.fit(X_trainAI_SD, y_trainAI_SD, eval_set=[(X_testAI_SD, y_testAI_SD)], eval_metric='auc')
pred = clf.predict_proba(X_testAI_SD)[:,1]
auc = roc_auc_score(y_testAI_SD, pred)
print("Human OOD AUC:", auc)

fi = pd.DataFrame({
    'feature': featureNames,
    'importance': clf.feature_importances_
}).sort_values('importance', ascending=False).reset_index(drop=True)
print(fi.head(20))

perm = permutation_importance(clf, X_testAI_SD, y_testAI_SD, n_repeats=10, random_state=42, scoring='roc_auc')
perm_df = pd.DataFrame({'feature': featureNames, 'perm_mean': perm.importances_mean, 'perm_std': perm.importances_std})
perm_df = perm_df.sort_values('perm_mean', ascending=False).reset_index(drop=True)
print(perm_df.head(20))

explainer = shap.TreeExplainer(clf)
shap_vals = explainer.shap_values(X_testAI_SD)  # for binary, this returns a list [class0, class1]
if isinstance(shap_vals, list) and len(shap_vals) == 2:
    shap_vals_pos = shap_vals[1]
else:
    shap_vals_pos = shap_vals
X_test_df = pd.DataFrame(X_testAI_SD, columns=featureNames)
shap.summary_plot(shap_vals_pos, X_test_df, feature_names=featureNames, plot_type="bar", show=False)
plt.title("AI_SD Art: Component importance in OOD-ID classification bar plot")
plt.show()
plt.close()
shap.summary_plot(shap_vals_pos, X_test_df, feature_names=featureNames, plot_type="dot", show=False)
plt.title("AI_SD Art: Component importance in OOD-ID classification dot plot")
plt.show()
plt.close()

# AI_LD classification
clf.fit(X_trainAI_LD, y_trainAI_LD, eval_set=[(X_testAI_LD, y_testAI_LD)], eval_metric='auc')
pred = clf.predict_proba(X_testAI_LD)[:,1]
auc = roc_auc_score(y_testAI_LD, pred)
print("Human OOD AUC:", auc)

fi = pd.DataFrame({
    'feature': featureNames,
    'importance': clf.feature_importances_
}).sort_values('importance', ascending=False).reset_index(drop=True)
print(fi.head(20))

perm = permutation_importance(clf, X_testAI_LD, y_testAI_LD, n_repeats=10, random_state=42, scoring='roc_auc')
perm_df = pd.DataFrame({'feature': featureNames, 'perm_mean': perm.importances_mean, 'perm_std': perm.importances_std})
perm_df = perm_df.sort_values('perm_mean', ascending=False).reset_index(drop=True)
print(perm_df.head(20))

explainer = shap.TreeExplainer(clf)
shap_vals = explainer.shap_values(X_testAI_LD)  # for binary, this returns a list [class0, class1]
if isinstance(shap_vals, list) and len(shap_vals) == 2:
    shap_vals_pos = shap_vals[1]
else:
    shap_vals_pos = shap_vals
X_test_df = pd.DataFrame(X_testAI_LD, columns=featureNames)
shap.summary_plot(shap_vals_pos, X_test_df, feature_names=featureNames, plot_type="bar", show=False)
plt.title("AI_LD Art: Component importance in OOD-ID classification bar plot")
plt.show()
plt.close()
shap.summary_plot(shap_vals_pos, X_test_df, feature_names=featureNames, plot_type="dot", show=False)
plt.title("AI_LD Art: Component importance in OOD-ID classification dot plot")
plt.show()
plt.close()