Assessing Feature Importance Consistency

Simply comparing aggregate performance metrics like accuracy or AUC, understanding why a model performs the way it does is often significant. A critical aspect of machine learning utility is whether a model trained on synthetic data learns similar underlying patterns and feature relationships as a model trained on the corresponding real data. If the synthetic data leads the model to rely on entirely different features or assign vastly different weights compared to the real data, its practical utility might be limited, even if overall performance metrics seem acceptable. Assessing feature importance consistency helps us gauge this alignment.

Feature importance quantifies the contribution of each input feature to a model's predictions. Common methods include:

• Permutation Importance: Measures the decrease in model score when a single feature's values are randomly shuffled.
• Coefficient Magnitudes: For linear models (like Linear Regression or Logistic Regression), the absolute value of the coefficients can indicate feature importance.
• Tree-Based Importance: Models like Random Forests or Gradient Boosting Trees provide impurity-based (e.g., Gini importance) or split-based importance measures.
• SHAP (SHapley Additive exPlanations) Values: A game-theoretic approach providing consistent and locally accurate feature attributions.

Our goal isn't to re-explain these methods but to use their outputs to compare models trained on real versus synthetic data. The core idea follows the Train-Synthetic-Test-Real (TSTR) principle, but instead of just evaluating predictions on the real test set, we also analyze the learned feature importances.

Comparing Importance Rankings and Magnitudes

The most straightforward approach involves these steps:

1. Train Model R: Train a chosen machine learning model (e.g., Random Forest, Gradient Boosting, Logistic Regression) on the real training dataset.
2. Calculate Importance R: Compute the feature importances for Model R using a chosen method (e.g., permutation importance).
3. Train Model S: Train the same type of model, ideally with the same hyperparameters, on the synthetic training dataset.
4. Calculate Importance S: Compute the feature importances for Model S using the same method as in step 2.
5. Compare: Analyze the similarity between Importance R and Importance S.

Several comparison techniques can be employed:

• Rank Correlation: Calculate the correlation between the rankings of features based on their importance scores. Spearman's Rho or Kendall's Tau are suitable metrics. A high rank correlation (close to 1) indicates that both models prioritize features similarly.

  $$\rho = 1 - \frac{6 \sum d_i^2}{n(n^2 - 1)}$$

  Spearman's Rank Correlation Coefficient formula, where $d_i$ is the difference between the ranks of feature $i$ in the two models, and $n$ is the number of features.

• Value Comparison (Scatter Plot): Create a scatter plot where each point represents a feature. The x-coordinate is its importance in Model R, and the y-coordinate is its importance in Model S. Features close to the $y=x$ line indicate good agreement in importance magnitude.

Scatter plot comparing the importance scores of features from a model trained on real data versus one trained on synthetic data. Points near the dashed diagonal line indicate consistent importance.

• Top-K Overlap: Identify the set of the top-K most important features for Model R and Model S. Calculate the size of the intersection of these sets (e.g., using the Jaccard index). This focuses on whether the most influential features are preserved.

Implementation Considerations

Consistency is important when performing this comparison.

• Model Choice: Use the exact same model class (e.g., sklearn.ensemble.RandomForestClassifier) for both real and synthetic data.
• Hyperparameters: Ideally, use the same hyperparameters. If hyperparameters were tuned separately for real and synthetic data (as discussed in the next section), be mindful that this difference might also influence feature importance. It might be informative to run the comparison using both the real-tuned and synthetic-tuned parameters on both models.
• Importance Method: Apply the identical feature importance calculation method (e.g., sklearn.inspection.permutation_importance with the same settings) to both models.
• Averaging: Feature importance estimates can have variance. Consider calculating importances over multiple runs with different random seeds or across cross-validation folds and comparing the average importances.

Here's a simplified Python snippet using scikit-learn's permutation importance and SciPy for rank correlation:

import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.inspection import permutation_importance
from scipy.stats import spearmanr
from sklearn.model_selection import train_test_split

# Assume X_real, y_real, X_synth are pre-loaded
# Split real data for training Model R
X_real_train, X_real_test, y_real_train, y_real_test = train_test_split(
    X_real, y_real, test_size=0.3, random_state=42
)

# 1 & 2: Train on Real, Get Importance R
model_r = RandomForestClassifier(n_estimators=100, random_state=42)
model_r.fit(X_real_train, y_real_train)
perm_importance_r = permutation_importance(
    model_r, X_real_test, y_real_test, n_repeats=10, random_state=42, n_jobs=-1
)
importance_r = perm_importance_r.importances_mean

# 3 & 4: Train on Synthetic, Get Importance S
# Assume X_synth has the same features as X_real
# Note: We use the *same* real test set for evaluation consistency
model_s = RandomForestClassifier(n_estimators=100, random_state=42) # Same model, same hypers
model_s.fit(X_synth, y_real_train) # Fit on synthetic data
perm_importance_s = permutation_importance(
    model_s, X_real_test, y_real_test, n_repeats=10, random_state=42, n_jobs=-1
)
importance_s = perm_importance_s.importances_mean

# 5: Compare
# Rank Correlation
spearman_corr, p_value = spearmanr(importance_r, importance_s)
print(f"Spearman Rank Correlation: {spearman_corr:.3f}")

# Top-K Overlap (e.g., K=5)
k = 5
top_k_indices_r = np.argsort(importance_r)[-k:]
top_k_indices_s = np.argsort(importance_s)[-k:]
overlap = len(set(top_k_indices_r) & set(top_k_indices_s))
print(f"Overlap in Top-{k} Features: {overlap}/{k}")

# (Visualization code for scatter plot would go here)

Interpreting Consistency Results

• High Consistency: A high rank correlation and significant overlap in top features suggest the synthetic data generation process successfully captured the feature relationships relevant to the prediction task. Models trained on this synthetic data are likely to behave similarly to those trained on real data regarding feature usage.
• Low Consistency: Poor correlation or little overlap indicates potential issues. The synthetic data might be missing important interactions, introducing spurious correlations, or oversimplifying the data structure. Models trained on such data might achieve reasonable aggregate scores (as measured by TSTR) but might not be reliable for generating insights or understanding the underlying data generating process.

Assessing feature importance consistency provides a deeper layer of utility evaluation than looking at performance metrics alone. It helps build confidence that the synthetic data not only allows for accurate predictions but also reflects the salient characteristics and relationships present in the original data. However, remember that feature importance methods have their own assumptions and limitations, so interpret these consistency results as valuable relative comparisons rather than absolute truths about feature relevance.