腹部手术并发症预测模型：scikit模型结构获取与特征缩减问询

Great work hitting that 0.94 score on your abdominal surgery complication prediction model—impressive stuff! Let’s walk through how to address both of your needs:

一、Inspecting Your Scikit-learn Model’s Underlying Structure #

The way you dig into a model’s internals depends on what type of model you’re using. Here are the most common approaches:

Linear Models (e.g., LogisticRegression, LinearRegression) #

If you’re using a linear model, you can directly access learned weights and intercepts:

# Print feature weights (one per input variable)
print(model.coef_)
# Print the model's intercept term
print(model.intercept_)

Tree-Based Models (e.g., RandomForestClassifier, GradientBoostingClassifier) #

These models have rich internal structures you can explore:

• Individual tree structure: Use estimators_ to access each tree in the ensemble, then visualize or print its structure:

  from sklearn.tree import export_text, plot_tree
  
  # Print the text representation of the first decision tree
  print(export_text(model.estimators_[0], feature_names=your_feature_list))
  # Plot the first tree (requires matplotlib)
  plot_tree(model.estimators_[0], feature_names=your_feature_list, filled=True)
  

• Feature importance scores: Tree models automatically calculate how much each feature contributes to predictions:

  # Array of importance scores, ordered matching your input features
  print(model.feature_importances_)
  

All Model Types #

For a quick snapshot of your model’s hyperparameters (the settings you used to train it), use get_params():

# Print all hyperparameters and their values
print(model.get_params())

二、Reducing Features from 100 to ~20 (and Validating Impact) #

To test how trimming features affects your model’s performance, try these proven feature selection methods:

1. Tree-Based Importance Filtering #

Use the feature importance scores from your existing tree model to pick the top 20 most impactful features:

import numpy as np

# Sort features by importance (descending order)
sorted_importance_indices = np.argsort(model.feature_importances_)[::-1]
# Select the top 20 features
top_20_features = your_feature_list[sorted_importance_indices[:20]]
# Extract the corresponding subset of your training data
X_reduced = X[:, sorted_importance_indices[:20]]

2. Statistical Test-Based Selection (SelectKBest) #

For linear models or when you want a stats-driven approach, use SelectKBest to pick features with the strongest relationship to your target variable:

from sklearn.feature_selection import SelectKBest, chi2

# For classification tasks, chi2 works well; use f_regression for regression
selector = SelectKBest(chi2, k=20)
X_reduced = selector.fit_transform(X, y)
# Get the names of the selected features
top_20_features = your_feature_list[selector.get_support()]

3. Recursive Feature Elimination (RFE) #

RFE iteratively removes the least useful features until you hit your target count—great for capturing feature interactions:

from sklearn.feature_selection import RFE
from sklearn.linear_model import LogisticRegression

# Use your existing model or a simple estimator as the "judge" for feature utility
rfe = RFE(estimator=LogisticRegression(max_iter=1000), n_features_to_select=20)
X_reduced = rfe.fit_transform(X, y)
top_20_features = your_feature_list[rfe.get_support()]

Validating the Impact #

Once you have your reduced feature set:

• Retrain your model using only the 20 selected features
• Evaluate it on the same test set you used for your original 100-feature model
• Compare metrics (accuracy, AUC, precision/recall—whichever matters most for your complication prediction task) to see if performance holds or changes

内容的提问来源于stack exchange，提问作者Wouter