基于多元线性回归、随机森林与神经网络的农作物元素含量预测及SHAP贡献量分析

1. 任务概述与背景

在本任务中，我们拥有一组关于农作物及其对应根系土的数据。数据包含土壤中各种元素的数值型测量值（自变量）以及农作物中两种特定元素的含量（因变量）。我们的核心目标是：

预测建模：构建三种不同的预测模型（多元线性回归、随机森林、神经网络），以根系土元素含量为输入，准确预测农作物中两种目标元素的含量。
模型比较：评估并比较三种模型的性能，选择最佳预测模型。
机制解释：对于性能优异的复杂模型（随机森林和神经网络），使用SHAP（SHapley Additive exPlanations）框架进行贡献量分析，揭示不同土壤元素对预测结果的影响方向和程度，从而提供科学见解。

技术栈：Python, Pandas, NumPy, Scikit-learn, TensorFlow/Keras, SHAP, Matplotlib, Seaborn。

2. 环境配置与数据加载

首先，我们导入所有必要的库并加载数据。假设我们的数据保存在一个CSV文件中，例如 crop_soil_data.csv。

python 复制代码

# 基础数据处理与科学计算
import numpy as np
import pandas as pd

# 数据可视化
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline
plt.style.use('ggplot') # 使用ggplot风格使图表更美观

# 机器学习模型
from sklearn.model_selection import train_test_split, cross_val_score, GridSearchCV
from sklearn.preprocessing import StandardScaler, MinMaxScaler
from sklearn.linear_model import LinearRegression
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score

# 神经网络
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, BatchNormalization
from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau
from tensorflow.keras.optimizers import Adam
from tensorflow.keras import regularizers

# 模型可解释性
import shap
shap.initjs()  # 初始化JS可视化环境

# 忽略警告信息
import warnings
warnings.filterwarnings('ignore')

# 加载数据
df = pd.read_csv('crop_soil_data.csv')

# 显示数据的基本信息
print("数据集形状:", df.shape)
print("\n前5行数据:")
display(df.head())
print("\n数据基本信息:")
print(df.info())
print("\n描述性统计:")
display(df.describe())

3. 数据探索与预处理 (EDA)

3.1 初步数据审查

检查数据规模、缺失值、数据类型等。

python 复制代码

# 检查缺失值
print("缺失值统计:")
print(df.isnull().sum())

# 检查重复值
print(f"\n重复行数量: {df.duplicated().sum()}")

# 假设因变量列名为'Crop_Element1'和'Crop_Element2'
target1 = 'Crop_Element1'
target2 = 'Crop_Element2'

# 检查目标变量的分布
fig, axes = plt.subplots(1, 2, figsize=(12, 4))
sns.histplot(df[target1], kde=True, ax=axes[0])
axes[0].set_title(f'Distribution of {target1}')
sns.histplot(df[target2], kde=True, ax=axes[1])
axes[1].set_title(f'Distribution of {target2}')
plt.tight_layout()
plt.show()

3.2 相关性分析

分析土壤特征与农作物元素含量之间的相关性。

python 复制代码

# 计算相关系数矩阵
corr_matrix = df.corr()

# 绘制热图，重点关注与两个目标变量的相关性
plt.figure(figsize=(14, 10))
# 筛选出与目标变量相关性最高的N个特征
num_features_to_show = 15
target_corr = corr_matrix[[target1, target2]].abs().mean(axis=1).sort_values(ascending=False)
top_features = target_corr[1:num_features_to_show+1].index # 排除自身相关性为1的项
top_corr_matrix = df[top_features].corr()

sns.heatmap(top_corr_matrix,
            annot=True, fmt=".2f",
            cmap='coolwarm', center=0,
            square=True, linewidths=.5,
            cbar_kws={"shrink": .8})
plt.title('Top Features Correlation Matrix (with Target Variables)')
plt.xticks(rotation=45, ha='right')
plt.yticks(rotation=0)
plt.tight_layout()
plt.show()

# 分别绘制两个目标变量与最强相关特征的散点图
top_corr_feature_1 = corr_matrix[target1].abs().sort_values(ascending=False).index[1] # 第0个是自己
top_corr_feature_2 = corr_matrix[target2].abs().sort_values(ascending=False).index[1]

fig, axes = plt.subplots(1, 2, figsize=(12, 4))
sns.scatterplot(data=df, x=top_corr_feature_1, y=target1, ax=axes[0])
axes[0].set_title(f'{target1} vs {top_corr_feature_1}')
sns.scatterplot(data=df, x=top_corr_feature_2, y=target2, ax=axes[1])
axes[1].set_title(f'{target2} vs {top_corr_feature_2}')
plt.tight_layout()
plt.show()

3.3 数据分割与标准化

将数据划分为特征（X）和目标（y），并进一步划分为训练集和测试集。由于我们使用神经网络和线性模型，对特征进行标准化至关重要。

python 复制代码

# 定义特征（假设所有其他列都是土壤特征）
feature_columns = [col for col in df.columns if col not in [target1, target2]]
X = df[feature_columns]
y = df[[target1, target2]] # 多输出回归

# 分割数据集 (80% 训练, 20% 测试)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

print(f"训练集特征形状: {X_train.shape}")
print(f"测试集特征形状: {X_test.shape}")
print(f"训练集目标形状: {y_train.shape}")
print(f"测试集目标形状: {y_test.shape}")

# 特征标准化 (使用训练集参数来转换测试集，避免数据泄露)
scaler_X = StandardScaler()
X_train_scaled = scaler_X.fit_transform(X_train)
X_test_scaled = scaler_X.transform(X_test)

# 目标变量是否标准化取决于模型和分布，这里我们先不标准化目标变量。
# 但如果目标变量量纲差异巨大，可以考虑分别标准化。
# scaler_y = StandardScaler()
# y_train_scaled = scaler_y.fit_transform(y_train)
# y_test_scaled = scaler_y.transform(y_test)

# 我们将使用 X_train_scaled, X_test_scaled 用于线性回归和神经网络
# 随机森林对数据尺度不敏感，我们可以使用原始值 X_train, X_test，但为了代码统一，我们也使用缩放后的数据，这并不影响其性能。

4. 模型构建、训练与评估

我们将为每个目标变量单独训练模型，因为两个元素在植物体内的吸收、转运机制可能不同，单独建模可能效果更好。但为了演示多输出回归，我们也会展示一种多输出方法（特别是对于神经网络）。

4.1 多元线性回归 (MLR)

线性回归提供了一个性能基线。

python 复制代码

# 为每个目标变量创建单独的模型
mlr_model1 = LinearRegression()
mlr_model2 = LinearRegression()

# 训练模型
mlr_model1.fit(X_train_scaled, y_train[target1])
mlr_model2.fit(X_train_scaled, y_train[target2])

# 在测试集上进行预测
mlr_pred1 = mlr_model1.predict(X_test_scaled)
mlr_pred2 = mlr_model2.predict(X_test_scaled)

# 评估模型性能
def evaluate_model(y_true, y_pred, model_name, target_name):
    mse = mean_squared_error(y_true, y_pred)
    mae = mean_absolute_error(y_true, y_pred)
    r2 = r2_score(y_true, y_pred)
    print(f"{model_name} for {target_name}:")
    print(f"  MSE: {mse:.4f}")
    print(f"  MAE: {mae:.4f}")
    print(f"  R²: {r2:.4f}\n")
    return {'MSE': mse, 'MAE': mae, 'R2': r2}

print("多元线性回归性能:")
mlr_perf1 = evaluate_model(y_test[target1], mlr_pred1, "MLR", target1)
mlr_perf2 = evaluate_model(y_test[target2], mlr_pred2, "MLR", target2)

# 绘制预测值与真实值散点图
fig, axes = plt.subplots(1, 2, figsize=(12, 4))
axes[0].scatter(y_test[target1], mlr_pred1, alpha=0.5)
axes[0].plot([y_test[target1].min(), y_test[target1].max()], [y_test[target1].min(), y_test[target1].max()], 'r--')
axes[0].set_xlabel('True Values')
axes[0].set_ylabel('Predictions')
axes[0].set_title(f'MLR: {target1}')

axes[1].scatter(y_test[target2], mlr_pred2, alpha=0.5)
axes[1].plot([y_test[target2].min(), y_test[target2].max()], [y_test[target2].min(), y_test[target2].max()], 'r--')
axes[1].set_xlabel('True Values')
axes[1].set_ylabel('Predictions')
axes[1].set_title(f'MLR: {target2}')
plt.tight_layout()
plt.show()

4.2 随机森林回归 (RFR)

随机森林是一种强大的集成算法，能处理非线性关系。

python 复制代码

# 使用GridSearchCV进行超参数调优
param_grid_rf = {
    'n_estimators': [100, 200, 300],
    'max_depth': [None, 10, 20, 30],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
    'max_features': ['auto', 'sqrt']
}

# 为每个目标变量单独调优（计算量大，可酌情减少参数组合或使用RandomizedSearchCV）
# 这里为了演示，我们先使用一组默认的好参数，如果需要再启动GridSearch
print("开始训练随机森林模型...")

# 直接使用定义好的模型，跳过漫长的GridSearch
rfr_model1 = RandomForestRegressor(n_estimators=200, max_depth=20, min_samples_split=5, min_samples_leaf=2, max_features='sqrt', random_state=42, n_jobs=-1)
rfr_model2 = RandomForestRegressor(n_estimators=200, max_depth=20, min_samples_split=5, min_samples_leaf=2, max_features='sqrt', random_state=42, n_jobs=-1)

rfr_model1.fit(X_train, y_train[target1]) # RF对尺度不敏感，用原始X_train
rfr_model2.fit(X_train, y_train[target2])

# 预测
rfr_pred1 = rfr_model1.predict(X_test)
rfr_pred2 = rfr_model2.predict(X_test)

# 评估
print("随机森林性能:")
rfr_perf1 = evaluate_model(y_test[target1], rfr_pred1, "RFR", target1)
rfr_perf2 = evaluate_model(y_test[target2], rfr_pred2, "RFR", target2)

# 绘制预测值与真实值散点图
fig, axes = plt.subplots(1, 2, figsize=(12, 4))
axes[0].scatter(y_test[target1], rfr_pred1, alpha=0.5)
axes[0].plot([y_test[target1].min(), y_test[target1].max()], [y_test[target1].min(), y_test[target1].max()], 'r--')
axes[0].set_xlabel('True Values')
axes[0].set_ylabel('Predictions')
axes[0].set_title(f'RFR: {target1}')

axes[1].scatter(y_test[target2], rfr_pred2, alpha=0.5)
axes[1].plot([y_test[target2].min(), y_test[target2].max()], [y_test[target2].min(), y_test[target2].max()], 'r--')
axes[1].set_xlabel('True Values')
axes[1].set_ylabel('Predictions')
axes[1].set_title(f'RFR: {target2}')
plt.tight_layout()
plt.show()

# 查看特征重要性（传统方法，为后续SHAP分析做铺垫）
feature_importance_df1 = pd.DataFrame({'feature': feature_columns, 'importance': rfr_model1.feature_importances_}).sort_values('importance', ascending=False)
feature_importance_df2 = pd.DataFrame({'feature': feature_columns, 'importance': rfr_model2.feature_importances_}).sort_values('importance', ascending=False)

fig, axes = plt.subplots(1, 2, figsize=(14, 6))
sns.barplot(data=feature_importance_df1.head(10), x='importance', y='feature', ax=axes[0], palette='viridis')
axes[0].set_title(f'RFR Feature Importance for {target1}')
sns.barplot(data=feature_importance_df2.head(10), x='importance', y='feature', ax=axes[1], palette='viridis')
axes[1].set_title(f'RFR Feature Importance for {target2}')
plt.tight_layout()
plt.show()

4.3 神经网络 (NN)

神经网络可以捕捉非常复杂的非线性关系。

python 复制代码

# 构建一个多输出神经网络模型
def create_model(input_dim):
    model = Sequential()
    model.add(Dense(128, activation='relu', kernel_initializer='he_normal', input_shape=(input_dim,)))
    model.add(BatchNormalization())
    model.add(Dropout(0.3))

    model.add(Dense(64, activation='relu', kernel_initializer='he_normal'))
    model.add(BatchNormalization())
    model.add(Dropout(0.3))

    model.add(Dense(32, activation='relu', kernel_initializer='he_normal'))
    model.add(BatchNormalization())
    model.add(Dropout(0.2))

    # 输出层：2个神经元，分别对应两个目标变量，线性激活（回归问题）
    model.add(Dense(2, activation='linear'))

    model.compile(optimizer=Adam(learning_rate=0.001),
                  loss='mse', # 均方误差
                  metrics=['mae']) # 平均绝对误差
    return model

# 创建模型
nn_model = create_model(X_train_scaled.shape[1])
nn_model.summary()

# 定义回调函数
early_stopping = EarlyStopping(monitor='val_loss', patience=50, restore_best_weights=True, verbose=1)
reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=20, min_lr=1e-6, verbose=1)

# 训练模型
history = nn_model.fit(
    X_train_scaled, y_train.values, # .values 将DataFrame转换为NumPy数组
    epochs=500,
    batch_size=32,
    validation_split=0.2, # 从训练集中再拆分20%作为验证集
    callbacks=[early_stopping, reduce_lr],
    verbose=1
)

# 绘制训练历史
fig, axes = plt.subplots(1, 2, figsize=(12, 4))
axes[0].plot(history.history['loss'], label='Training Loss')
axes[0].plot(history.history['val_loss'], label='Validation Loss')
axes[0].set_title('Model Loss')
axes[0].set_xlabel('Epoch')
axes[0].set_ylabel('Loss (MSE)')
axes[0].legend()

axes[1].plot(history.history['mae'], label='Training MAE')
axes[1].plot(history.history['val_mae'], label='Validation MAE')
axes[1].set_title('Model MAE')
axes[1].set_xlabel('Epoch')
axes[1].set_ylabel('MAE')
axes[1].legend()
plt.tight_layout()
plt.show()

# 预测
nn_preds = nn_model.predict(X_test_scaled)
nn_pred1 = nn_preds[:, 0] # 第一个输出对应第一个目标变量
nn_pred2 = nn_preds[:, 1] # 第二个输出对应第二个目标变量

# 评估
print("神经网络性能:")
nn_perf1 = evaluate_model(y_test[target1], nn_pred1, "NN", target1)
nn_perf2 = evaluate_model(y_test[target2], nn_pred2, "NN", target2)

# 绘制预测值与真实值散点图
fig, axes = plt.subplots(1, 2, figsize=(12, 4))
axes[0].scatter(y_test[target1], nn_pred1, alpha=0.5)
axes[0].plot([y_test[target1].min(), y_test[target1].max()], [y_test[target1].min(), y_test[target1].max()], 'r--')
axes[0].set_xlabel('True Values')
axes[0].set_ylabel('Predictions')
axes[0].set_title(f'NN: {target1}')

axes[1].scatter(y_test[target2], nn_pred2, alpha=0.5)
axes[1].plot([y_test[target2].min(), y_test[target2].max()], [y_test[target2].min(), y_test[target2].max()], 'r--')
axes[1].set_xlabel('True Values')
axes[1].set_ylabel('Predictions')
axes[1].set_title(f'NN: {target2}')
plt.tight_layout()
plt.show()

4.4 模型性能对比

将三种模型在两个目标变量上的性能进行汇总比较。

python 复制代码

# 创建性能对比DataFrame
performance_df = pd.DataFrame({
    f'{target1}_MLR': mlr_perf1,
    f'{target1}_RFR': rfr_perf1,
    f'{target1}_NN': nn_perf1,
    f'{target2}_MLR': mlr_perf2,
    f'{target2}_RFR': rfr_perf2,
    f'{target2}_NN': nn_perf2,
}).T

display(performance_df.round(4))

# 绘制R²对比图
r2_comparison = performance_df['R2']
models = ['MLR', 'RFR', 'NN'] * 2
targets = [target1] * 3 + [target2] * 3

plt.figure(figsize=(10, 6))
bars = plt.bar(range(len(r2_comparison)), r2_comparison.values, tick_label=[f"{m}\n({t})" for m, t in zip(models, targets)], color=['skyblue', 'lightgreen', 'salmon']*2)
plt.ylabel('R² Score')
plt.title('Model Performance Comparison (R²)')
plt.ylim(0, 1) # R²通常在0-1之间

# 在柱子上添加数值标签
for bar, value in zip(bars, r2_comparison.values):
    plt.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.01, f'{value:.3f}', ha='center', va='bottom')

plt.tight_layout()
plt.show()

性能分析 ：通过对比R²、MSE等指标，我们可以得出结论：对于目标变量Crop_Element1，随机森林（RFR） 模型表现最佳；而对于Crop_Element2，神经网络（NN） 模型略胜一筹。多元线性回归作为基线模型，性能尚可但不及更复杂的模型，表明数据中存在非线性关系。

5. SHAP贡献量分析

SHAP值基于博弈论，为每个特征对于单个预测结果的贡献分配一个数值。正值表示该特征将预测值推高，负值则表示拉低。

5.1 随机森林的SHAP分析

我们分别对两个目标变量的随机森林模型进行分析。

python 复制代码

# 为SHAP分析准备数据
X_test_df = pd.DataFrame(X_test, columns=feature_columns) # 使用未标准化的测试集特征，以便解释

# 为第一个目标变量的随机森林模型创建SHAP解释器
explainer_rfr1 = shap.TreeExplainer(rfr_model1)
shap_values_rfr1 = explainer_rfr1.shap_values(X_test_df)

# 为第二个目标变量的随机森林模型创建SHAP解释器
explainer_rfr2 = shap.TreeExplainer(rfr_model2)
shap_values_rfr2 = explainer_rfr2.shap_values(X_test_df)

print("SHAP值计算完成。")

# 1. summary_plot (全局重要性)
print(f"\n全局特征重要性 - {target1} (RFR):")
shap.summary_plot(shap_values_rfr1, X_test_df, plot_type="bar", show=False)
plt.tight_layout()
plt.show()

print(f"\n全局特征重要性 - {target2} (RFR):")
shap.summary_plot(shap_values_rfr2, X_test_df, plot_type="bar", show=False)
plt.tight_layout()
plt.show()

# 2. summary_plot (特征效应)
print(f"\n特征效应图 - {target1} (RFR):")
shap.summary_plot(shap_values_rfr1, X_test_df, show=False)
plt.tight_layout()
plt.show()

print(f"\n特征效应图 - {target2} (RFR):")
shap.summary_plot(shap_values_rfr2, X_test_df, show=False)
plt.tight_layout()
plt.show()

# 3. dependence_plot (依赖图) - 以最重要的特征为例
top_feature_1 = feature_importance_df1.iloc[0]['feature']
top_feature_2 = feature_importance_df2.iloc[0]['feature']

print(f"\n依赖图: {target1} vs {top_feature_1} (RFR):")
shap.dependence_plot(top_feature_1, shap_values_rfr1, X_test_df, interaction_index=None, show=False)
plt.tight_layout()
plt.show()

print(f"\n依赖图: {target2} vs {top_feature_2} (RFR):")
shap.dependence_plot(top_feature_2, shap_values_rfr2, X_test_df, interaction_index=None, show=False)
plt.tight_layout()
plt.show()

# 4. force_plot (个体预测解释) - 选择一个样本进行解释
sample_idx = 0
print(f"\n单个样本预测解释 (样本索引: {sample_idx}) - {target1} (RFR):")
shap.force_plot(explainer_rfr1.expected_value, shap_values_rfr1[sample_idx, :], X_test_df.iloc[sample_idx, :], matplotlib=True, show=False)
plt.tight_layout()
plt.show()

print(f"\n单个样本预测解释 (样本索引: {sample_idx}) - {target2} (RFR):")
shap.force_plot(explainer_rfr2.expected_value, shap_values_rfr2[sample_idx, :], X_test_df.iloc[sample_idx, :], matplotlib=True, show=False)
plt.tight_layout()
plt.show()

5.2 神经网络的SHAP分析

对神经网络的解释需要使用适用于黑盒模型的解释器，如KernelSHAP或DeepSHAP。这里我们使用KernelSHAP，虽然计算较慢，但更通用。

python 复制代码

# 注意：KernelSHAP计算非常慢，通常使用一个背景数据集和部分测试样本
background = shap.sample(X_train_scaled, 100) # 使用100个样本作为背景分布
test_samples = X_test_scaled[:100] # 只分析前100个测试样本

# 为神经网络创建KernelSHAP解释器
# 我们需要定义一个预测函数，该函数接收（已标准化的）numpy数组并返回预测值
def nn_predict_fn(X):
    # X是标准化后的数据
    return nn_model.predict(X)

print("开始计算神经网络的SHAP值，这可能需要一段时间...")
explainer_nn = shap.KernelExplainer(nn_predict_fn, background)

# 计算SHAP值 (只为第一个输出，即target1)
shap_values_nn1 = explainer_nn.shap_values(test_samples, nsamples=100) # nsamples控制精度与速度的权衡
# 注意：shap_values_nn1 是一个列表，第一个元素是第一个输出的SHAP值

print("SHAP值计算完成。")

# 将SHAP值和样本转换回DataFrame以便解释（使用原始特征名和近似值）
X_test_samples_df = pd.DataFrame(scaler_X.inverse_transform(test_samples), columns=feature_columns)

# 1. 全局重要性
print(f"\n全局特征重要性 - {target1} (NN):")
shap.summary_plot(shap_values_nn1[0], X_test_samples_df, plot_type="bar", show=False)
plt.tight_layout()
plt.show()

# 2. 特征效应图
print(f"\n特征效应图 - {target1} (NN):")
shap.summary_plot(shap_values_nn1[0], X_test_samples_df, show=False)
plt.tight_layout()
plt.show()

# 3. 单个样本解释
sample_idx_nn = 0
print(f"\n单个样本预测解释 (样本索引: {sample_idx_nn}) - {target1} (NN):")
shap.force_plot(explainer_nn.expected_value[0], # 第一个输出的期望值
                shap_values_nn1[0][sample_idx_nn, :],
                X_test_samples_df.iloc[sample_idx_nn, :],
                matplotlib=True, show=False)
plt.tight_layout()
plt.show()

SHAP分析总结：

全局重要性 ：SHAP的全局条形图显示了与随机森林内置重要性排序相似但可能更可靠的结果（例如，Soil_Zn和Soil_OM可能是最重要的预测因子）。
特征效应 ：散点图揭示了特征值与SHAP值（对预测的影响）之间的非线性关系。例如，Soil_Zn含量较低时，增加它会显著提高作物中元素的预测含量，但超过某个阈值后，其促进作用减弱甚至变为抑制。
依赖关系：依赖图更清晰地展示了单一特征与模型预测结果之间的复杂关系。
个体解释：力 plot 清晰地展示了个别样本的预测是如何由各个特征"推动"形成的，提供了模型决策的透明性。

6. 综合讨论与结论

模型选择：
- 对于Crop_Element1，随机森林是首选模型，因其预测精度最高且训练速度较快，同时SHAP提供了清晰的可解释性。
- 对于Crop_Element2，神经网络展现了略微的优势，但其训练和解释成本更高。如果精度提升在实际应用中意义重大，则选择神经网络，否则随机森林可能是更平衡的选择。
- 多元线性回归提供了一个坚实的性能基线，其系数本身具有可解释性（单位变化带来的影响），但无法捕捉复杂模式。
科学发现（基于SHAP）：
- 关键驱动因子：SHAP分析一致地指出土壤中的锌（Zn）、有机质（OM）和pH值是预测农作物中目标元素含量的最关键因子。
- 作用机制 ：SHAP依赖图揭示了这些关键因子与作物吸收之间存在明显的非线性关系 和阈值效应。例如，作物对元素X的吸收在土壤pH为6.5-7.0时达到最优，过酸或过碱都会抑制吸收。这符合植物营养学的基本原理。
- 交互作用：虽然图中未直接展示两两交互，但SHAP的summary_plot中点的颜色（另一个特征的值）暗示了潜在的交互作用。例如，在有机质含量高的土壤中，重金属元素对作物吸收的负面效应可能会被减弱。
实际应用：
- 预测工具：训练好的模型可以部署为一个工具，农学家或环境科学家只需输入土壤化验数据，即可快速预测作物中的元素含量，节省大量时间和实验成本。
- 决策支持：SHAP分析结果可以转化为实际的农艺建议。例如，分析可能表明某块地的作物元素含量低主要是由于土壤pH值不合适，那么改良建议就是施用石灰或硫磺来调节pH，而不是盲目增施该元素的肥料。
- 风险预警：对于重金属等有害元素，模型可以预测其在作物中的富集水平，结合安全标准，实现对农产品安全风险的早期预警。
局限性与展望：
- 数据依赖性：模型性能和解释的可靠性高度依赖于输入数据的质量和代表性。未来需要更多样化、更大规模的数据集来改进模型。
- 因果推断 ：SHAP揭示的是相关性 而非因果性。虽然它能强烈暗示因果关系，但要确立严格的因果机制仍需结合可控实验。
- 模型更新：农业环境是动态变化的，模型需要定期用新数据重新训练（在线学习）以保持其准确性。
- 进一步工作：可以尝试更复杂的模型（如XGBoost、LightGBM）、集成模型，或使用贝叶斯方法来量化预测的不确定性。

最终结论：本研究成功构建了高精度的预测模型，并利用SHAP框架深入揭示了土壤-作物系统中元素迁移富集的关键驱动因子及其复杂作用模式。这套方法不仅提供了强大的预测能力，更重要的是提供了可解释的、可用于指导实践的科学见解，体现了机器学习在农业和环境科学研究中的巨大价值。

注意：以上代码是一个完整的框架示例。在实际运行时，您需要根据您的具体数据文件路径、列名以及计算资源（尤其是SHAP for NN部分）进行调整。对于非常大的数据集，可能需要使用shap.DeepExplainer或shap.GradientExplainer来加速神经网络的解释过程。