矿物类型分类实战：从数据预处理到多模型对比

在地质勘探与矿物分析领域，基于矿物成分数据实现自动化分类是提升分析效率的关键。本文将完整复盘一个矿物类型分类项目，涵盖数据清洗、缺失值填充、样本均衡处理，并对比 6 种传统机器学习模型与 2 种深度学习模型的分类效果，为类似数据驱动的分类任务提供可复用的解决方案。

一、项目背景与数据概况

1. 项目目标

基于矿物的化学成分特征（如镁、铝、硅等元素含量），将矿物分为 A、B、C、D 四类（已剔除特殊类别 E），通过对比不同数据预处理方法与模型，找到最优分类方案。

2. 数据特点

• 原始数据存储于矿物数据.xls，包含 “序号”“矿物类型” 及 7 个化学成分特征列；
• 存在三类数据问题：字符串格式数值（如 "12.3"）、特殊符号（如 ""）、空格与缺失值（NaN）；
• 样本存在类别不均衡问题，后续需通过 SMOTE 算法处理；
• 部分特征列缺失率较高，需针对性选择缺失值填充方法。

二、完整数据预处理流程

数据预处理直接影响模型效果，本项目采用 “清洗→填充→标准化→均衡” 四步流程，确保数据质量。

1. 数据清洗：统一格式与剔除异常

首先处理格式混乱问题，将非数值数据转为 NaN，便于后续填充：

import pandas as pd# 读取数据并剔除类别E（仅1条，无统计意义）
data = pd.read_excel("矿物数据.xls")
data = data[data['矿物类型'] != 'E']# 提取特征与标签（删除序号列，避免干扰模型训练）
X_whole = data.drop('矿物类型', axis=1).drop('序号', axis=1)
y_whole = data['矿物类型']# 处理异常格式：字符串数值/特殊符号→NaN（仅保留可转为float的值）
for col in X_whole.columns:X_whole[col] = pd.to_numeric(X_whole[col], errors='coerce')# 标签编码（将文字标签转为数字，适配模型输入：A→0, B→1, C→2, D→3）
label_dict = {"A": 0, "B": 1, "C": 2, "D": 3}
y_whole = pd.Series([label_dict[label] for label in y_whole], name='矿物类型')

2. 缺失值填充：6 种方法完整代码实现

缺失值是本数据的核心问题之一，我们设计了传统统计方法与机器学习方法两类共 6 种填充策略，并封装为可直接调用的函数，适配训练集与测试集（测试集需用训练集参数填充，避免数据泄露）。

2.1 工具函数封装：fill_data.py 完整代码

import pandas as pd
from sklearn.linear_model import LinearRegression
from sklearn.ensemble import RandomForestRegressor"""
1. CCA（Complete Case Analysis）：直接删除含缺失值的行
适用场景：缺失率极低（<5%），数据量充足时使用
"""
def cca_train_fill(train_data, train_label):# 合并特征与标签，便于统一删除含缺失值的行data = pd.concat([train_data, train_label], axis=1).reset_index(drop=True)# 删除所有含NaN的行df_filled = data.dropna()# 拆分回特征与标签return df_filled.drop('矿物类型', axis=1), df_filled['矿物类型']def cca_test_fill(train_data, train_label, test_data, test_label):# 测试集处理逻辑与训练集一致（仅删除自身缺失行，不依赖训练集）data = pd.concat([test_data, test_label], axis=1).reset_index(drop=True)df_filled = data.dropna()return df_filled.drop('矿物类型', axis=1), df_filled['矿物类型']"""
2. 平均值填充：按矿物类别计算均值，填充同类缺失值
适用场景：特征分布近似正态，无极端异常值
"""
def _mean_fill_method(data):# 计算每列均值（按类别分组后内部计算）fill_values = data.mean()return data.fillna(fill_values)def mean_train_fill(train_data, train_label):# 合并数据并按类别拆分（A/B/C/D四类分别填充）data = pd.concat([train_data, train_label], axis=1).reset_index(drop=True)class_A = data[data['矿物类型'] == 0]class_B = data[data['矿物类型'] == 1]class_C = data[data['矿物类型'] == 2]class_D = data[data['矿物类型'] == 3]# 按类别填充后合并filled_A = _mean_fill_method(class_A)filled_B = _mean_fill_method(class_B)filled_C = _mean_fill_method(class_C)filled_D = _mean_fill_method(class_D)df_filled = pd.concat([filled_A, filled_B, filled_C, filled_D]).reset_index(drop=True)return df_filled.drop('矿物类型', axis=1), df_filled['矿物类型']def mean_test_fill(train_data, train_label, test_data, test_label):# 训练集：按类别计算均值（作为测试集填充依据）train_all = pd.concat([train_data, train_label], axis=1).reset_index(drop=True)train_A = train_all[train_all['矿物类型'] == 0]train_B = train_all[train_all['矿物类型'] == 1]train_C = train_all[train_all['矿物类型'] == 2]train_D = train_all[train_all['矿物类型'] == 3]# 测试集：按类别拆分，用训练集同类均值填充test_all = pd.concat([test_data, test_label], axis=1).reset_index(drop=True)test_A = test_all[test_all['矿物类型'] == 0].fillna(train_A.mean())test_B = test_all[test_all['矿物类型'] == 1].fillna(train_B.mean())test_C = test_all[test_all['矿物类型'] == 2].fillna(train_C.mean())test_D = test_all[test_all['矿物类型'] == 3].fillna(train_D.mean())df_filled = pd.concat([test_A, test_B, test_C, test_D]).reset_index(drop=True)return df_filled.drop('矿物类型', axis=1), df_filled['矿物类型']"""
3. 中位数填充：按类别计算中位数，抗极端值干扰
适用场景：特征含离群点（如个别样本成分异常高）
"""
def _median_fill_method(data):fill_values = data.median()return data.fillna(fill_values)def median_train_fill(train_data, train_label):# 逻辑与平均值填充一致，仅将均值改为中位数data = pd.concat([train_data, train_label], axis=1).reset_index(drop=True)class_A = _median_fill_method(data[data['矿物类型'] == 0])class_B = _median_fill_method(data[data['矿物类型'] == 1])class_C = _median_fill_method(data[data['矿物类型'] == 2])class_D = _median_fill_method(data[data['矿物类型'] == 3])df_filled = pd.concat([class_A, class_B, class_C, class_D]).reset_index(drop=True)return df_filled.drop('矿物类型', axis=1), df_filled['矿物类型']def median_test_fill(train_data, train_label, test_data, test_label):# 测试集用训练集同类中位数填充train_all = pd.concat([train_data, train_label], axis=1).reset_index(drop=True)train_A_median = train_all[train_all['矿物类型'] == 0].median()train_B_median = train_all[train_all['矿物类型'] == 1].median()train_C_median = train_all[train_all['矿物类型'] == 2].median()train_D_median = train_all[train_all['矿物类型'] == 3].median()test_all = pd.concat([test_data, test_label], axis=1).reset_index(drop=True)test_A = test_all[test_all['矿物类型'] == 0].fillna(train_A_median)test_B = test_all[test_all['矿物类型'] == 1].fillna(train_B_median)test_C = test_all[test_all['矿物类型'] == 2].fillna(train_C_median)test_D = test_all[test_all['矿物类型'] == 3].fillna(train_D_median)df_filled = pd.concat([test_A, test_B, test_C, test_D]).reset_index(drop=True)return df_filled.drop('矿物类型', axis=1), df_filled['矿物类型']"""
4. 众数填充：按类别取出现频次最高的值，适配离散特征
适用场景：类别型特征（如“颜色等级”）或离散数值特征
"""
def _mode_fill_method(data):# 处理多众数情况（取第一个众数）fill_values = data.apply(lambda x: x.mode().iloc[0] if len(x.mode()) > 0 else None)return data.fillna(fill_values)def mode_train_fill(train_data, train_label):data = pd.concat([train_data, train_label], axis=1).reset_index(drop=True)class_A = _mode_fill_method(data[data['矿物类型'] == 0])class_B = _mode_fill_method(data[data['矿物类型'] == 1])class_C = _mode_fill_method(data[data['矿物类型'] == 2])class_D = _mode_fill_method(data[data['矿物类型'] == 3])df_filled = pd.concat([class_A, class_B, class_C, class_D]).reset_index(drop=True)return df_filled.drop('矿物类型', axis=1), df_filled['矿物类型']def mode_test_fill(train_data, train_label, test_data, test_label):# 训练集按类别计算众数train_all = pd.concat([train_data, train_label], axis=1).reset_index(drop=True)train_A_mode = train_all[train_all['矿物类型'] == 0].apply(lambda x: x.mode().iloc[0] if len(x.mode())>0 else None)train_B_mode = train_all[train_all['矿物类型'] == 1].apply(lambda x: x.mode().iloc[0] if len(x.mode())>0 else None)train_C_mode = train_all[train_all['矿物类型'] == 2].apply(lambda x: x.mode().iloc[0] if len(x.mode())>0 else None)train_D_mode = train_all[train_all['矿物类型'] == 3].apply(lambda x: x.mode().iloc[0] if len(x.mode())>0 else None)# 测试集填充test_all = pd.concat([test_data, test_label], axis=1).reset_index(drop=True)test_A = test_all[test_all['矿物类型'] == 0].fillna(train_A_mode)test_B = test_all[test_all['矿物类型'] == 1].fillna(train_B_mode)test_C = test_all[test_all['矿物类型'] == 2].fillna(train_C_mode)test_D = test_all[test_all['矿物类型'] == 3].fillna(train_D_mode)df_filled = pd.concat([test_A, test_B, test_C, test_D]).reset_index(drop=True)return df_filled.drop('矿物类型', axis=1), df_filled['矿物类型']"""
5. 线性回归填充：用其他特征预测缺失值，适配线性相关特征
核心逻辑：按缺失率从小到大处理（先填缺失少的，保证输入特征质量）
"""
def lr_train_fill(train_data, train_label):train_all = pd.concat([train_data, train_label], axis=1).reset_index(drop=True)X = train_all.drop('矿物类型', axis=1)# 按缺失率排序（优先处理缺失少的特征）null_sorted = X.isnull().sum().sort_values(ascending=True)for col in null_sorted.index:# 无缺失值则跳过if null_sorted[col] == 0:continue# 构建训练数据：用其他特征预测当前缺失特征# 输入特征：除当前列外的其他特征（已填充完缺失少的列）X_train_input = X.drop(col, axis=1)# 目标特征：当前列的非缺失值y_train_target = X[col].dropna()# 剔除目标特征缺失的行（仅用完整数据训练）X_train_input = X_train_input.loc[y_train_target.index]# 待预测的缺失行索引missing_rows = X[X[col].isnull()].index# 训练线性回归模型并填充lr = LinearRegression()lr.fit(X_train_input, y_train_target)# 预测缺失值并赋值X.loc[missing_rows, col] = lr.predict(X_train_input.loc[missing_rows])print(f"线性回归填充完成：训练集[{col}]列")return X, train_all['矿物类型']def lr_test_fill(train_data, train_label, test_data, test_label):# 训练集：用已填充好的训练集构建模型train_all = pd.concat([train_data, train_label], axis=1).reset_index(drop=True)X_train = train_all.drop('矿物类型', axis=1)# 测试集：需填充的原始数据test_all = pd.concat([test_data, test_label], axis=1).reset_index(drop=True)X_test = test_all.drop('矿物类型', axis=1)# 按缺失率排序处理null_sorted = X_test.isnull().sum().sort_values(ascending=True)for col in null_sorted.index:if null_sorted[col] == 0:continue# 用训练集的其他特征预测当前列（测试集缺失值）X_train_input = X_train.drop(col, axis=1)y_train_target = X_train[col]# 测试集输入特征（待预测行）missing_rows = X_test[X_test[col].isnull()].indexX_test_input = X_test.drop(col, axis=1).loc[missing_rows]# 训练模型并填充测试集lr = LinearRegression()lr.fit(X_train_input, y_train_target)X_test.loc[missing_rows, col] = lr.predict(X_test_input)print(f"线性回归填充完成：测试集[{col}]列")return X_test, test_all['矿物类型']"""
6. 随机森林填充：用集成模型预测缺失值，适配非线性关系
优势：抗过拟合能力强，预测精度高于线性回归
"""
def rf_train_fill(train_data, train_label):train_all = pd.concat([train_data, train_label], axis=1).reset_index(drop=True)X = train_all.drop('矿物类型', axis=1)null_sorted = X.isnull().sum().sort_values(ascending=True)for col in null_sorted.index:if null_sorted[col] == 0:continue# 构建训练数据（逻辑与线性回归一致）X_train_input = X.drop(col, axis=1)y_train_target = X[col].dropna()X_train_input = X_train_input.loc[y_train_target.index]missing_rows = X[X[col].isnull()].index# 训练随机森林回归模型（100棵树，保证稳定性）rf = RandomForestRegressor(n_estimators=100, random_state=42)rf.fit(X_train_input, y_train_target)# 填充缺失值X.loc[missing_rows, col] = rf.predict(X_train_input.loc[missing_rows])print(f"随机森林填充完成：训练集[{col}]列")return X, train_all['矿物类型']def rf_test_fill(train_data, train_label, test_data, test_label):train_all = pd.concat([train_data, train_label], axis=1).reset_index(drop=True)X_train = train_all.drop('矿物类型', axis=1)test_all = pd.concat([test_data, test_label], axis=1).reset_index(drop=True)X_test = test_all.drop('矿物类型', axis=1)null_sorted = X_test.isnull().sum().sort_values(ascending=True)for col in null_sorted.index:if null_sorted[col] == 0:continue# 用训练集训练模型，预测测试集缺失值X_train_input = X_train.drop(col, axis=1)y_train_target = X_train[col]missing_rows = X_test[X_test[col].isnull()].indexX_test_input = X_test.drop(col, axis=1).loc[missing_rows]rf = RandomForestRegressor(n_estimators=100, random_state=42)rf.fit(X_train_input, y_train_target)X_test.loc[missing_rows, col] = rf.predict(X_test_input)

2. 缺失值填充：6 种方法对比

缺失值是本数据的核心问题之一，我们设计了传统统计方法与机器学习方法两类共 6 种填充策略，并封装为fill_data.py工具函数，核心思路如下：

以随机森林填充（效果最优）为例，核心代码逻辑（fill_data.py）：

from sklearn.ensemble import RandomForestRegressordef rf_train_fill(train_data, train_label):# 合并特征与标签，便于按类别处理train_all = pd.concat([train_data, train_label], axis=1).reset_index(drop=True)X = train_all.drop('矿物类型', axis=1)# 按缺失率从小到大处理（先填缺失少的，保证输入特征质量）null_sorted = X.isnull().sum().sort_values(ascending=True)for col in null_sorted.index:if null_sorted[col] == 0:continue  # 无缺失，跳过# 构建训练集（非缺失行）与测试集（缺失行）X_train = X.drop(col, axis=1).dropna(subset=[col])  # 输入特征（不含当前列）y_train = X[col].dropna()  # 目标特征（非缺失值）missing_rows = X[X[col].isnull()].index  # 缺失行索引X_test = X.drop(col, axis=1).loc[missing_rows]  # 待预测的缺失行# 训练随机森林并填充rf = RandomForestRegressor(n_estimators=100, random_state=42)rf.fit(X_train, y_train)X.loc[missing_rows, col] = rf.predict(X_test)print(f"完成训练集[{col}]列填充")return X, train_all['矿物类型']

3. 数据标准化与数据集划分

为消除特征量纲影响（如 “硅含量” 数值远大于 “钠含量”），采用Z 标准化（均值 = 0，标准差 = 1）；同时按 7:3 比例划分训练集与测试集，确保随机性可复现（random_state=50000）：

from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split# Z标准化
scaler = StandardScaler()
X_whole_Z = scaler.fit_transform(X_whole)
X_whole = pd.DataFrame(X_whole_Z, columns=X_whole.columns)# 划分训练集/测试集（测试集占30%）
x_train, x_test, y_train, y_test = train_test_split(X_whole, y_whole, test_size=0.3, random_state=50000
)# 调用随机森林填充（可替换为其他填充方法）
import fill_data
x_train_fill, y_train_fill = fill_data.rf_train_fill(x_train, y_train)
x_test_fill, y_test_fill = fill_data.rf_test_fill(x_train_fill, y_train_fill, x_test, y_test)

4. 样本均衡：SMOTE 过采样

矿物数据存在类别不均衡（如 A 类样本远多于 D 类），直接训练会导致模型偏向多数类。采用SMOTE 算法（合成少数类样本）平衡训练集：

from imblearn.over_sampling import SMOTE# 仅对训练集过采样（避免测试集数据泄露）
oversampler = SMOTE(k_neighbors=1, random_state=42)
os_x_train, os_y_train = oversampler.fit_resample(x_train_fill, y_train_fill)# 可视化均衡后的数据分布
import matplotlib.pyplot as plt
labels_count = pd.value_counts(pd.concat([os_y_train, y_test_fill]))
plt.bar(labels_count.index, labels_count.values)
plt.xlabel('矿物类别（0=A,1=B,2=C,3=D）')
plt.ylabel('样本数量')
plt.title('SMOTE均衡后各类别样本数')
plt.show()

三、多模型训练与效果对比

我们选择了6 种传统机器学习模型与2 种深度学习模型，统一使用 “accuracy（准确率）” 与 “各类别召回率” 作为评估指标，核心在于对比不同模型对 “小样本类别” 的分类能力。

1. 传统机器学习模型（基于 Scikit-learn）

所有模型均先通过网格搜索（GridSearchCV） 调优超参数，再用调优后的参数训练最终模型，以下为关键模型实现：

（1）随机森林（RF）：抗过拟合强，适合非线性数据

from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report# 调优后参数（网格搜索结果）
rf = RandomForestClassifier(bootstrap=False, max_depth=20, max_features='auto',min_samples_leaf=1, min_samples_split=2, n_estimators=100, random_state=0
)# 训练与评估
rf.fit(os_x_train, os_y_train)
y_pred_rf = rf.predict(x_test_fill)
print("随机森林测试集报告：")
print(classification_report(y_test_fill, y_pred_rf, target_names=['A', 'B', 'C', 'D']))

（2）XGBoost：梯度提升，对小样本类别敏感

import xgboost as xgbxgb_model = xgb.XGBClassifier(learning_rate=0.1, n_estimators=200, max_depth=7,min_child_weight=1, gamma=0.1, subsample=0.8,colsample_bytree=0.8, objective='multi:softmax', num_class=4, seed=0
)xgb_model.fit(os_x_train, os_y_train)
y_pred_xgb = xgb_model.predict(x_test_fill)
print("XGBoost测试集报告：")
print(classification_report(y_test_fill, y_pred_xgb, target_names=['A', 'B', 'C', 'D']))

2. 深度学习模型（基于 PyTorch）

针对特征维度较低（仅 7 维）的特点，设计了全连接神经网络与1D-CNN（适配一维特征序列）：

（1）全连接神经网络（FCN）

import torch
import torch.nn as nnclass FCN(nn.Module):def __init__(self):super(FCN, self).__init__()self.fc1 = nn.Linear(7, 32)  # 输入维度=7（特征数）self.fc2 = nn.Linear(32, 64)self.fc3 = nn.Linear(64, 4)   # 输出维度=4（类别数）def forward(self, x):x = torch.relu(self.fc1(x))x = torch.relu(self.fc2(x))return self.fc3(x)# 数据转为张量
X_train_tensor = torch.tensor(os_x_train.values, dtype=torch.float32)
y_train_tensor = torch.tensor(os_y_train.values)
X_test_tensor = torch.tensor(x_test_fill.values, dtype=torch.float32)
y_test_tensor = torch.tensor(y_test_fill.values)# 训练配置
model = FCN()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)# 训练循环（10000轮，每100轮打印一次）
for epoch in range(10000):optimizer.zero_grad()outputs = model(X_train_tensor)loss = criterion(outputs, y_train_tensor)loss.backward()optimizer.step()if (epoch + 1) % 100 == 0:# 测试集准确率with torch.no_grad():pred = model(X_test_tensor).argmax(1)acc = (pred == y_test_tensor).float().mean().item()print(f"Epoch {epoch+1:5d} | Loss: {loss.item():.4f} | Test Acc: {acc:.4f}")

3. 模型效果汇总

经过实验，随机森林与XGBoost表现最优，各模型测试集准确率对比如下：

四、关键结论与经验总结

1. 缺失值填充方法选择：
   随机森林填充 > 中位数填充 > 平均值填充，当特征存在非线性关系时，机器学习填充方法远优于传统统计方法。

2. 模型选型建议：
   对于小样本、低维度的分类任务，优先选择 XGBoost 或随机森林，而非深度学习模型 —— 传统集成模型无需大量数据，且对类别不均衡的适应性更强。

3. 样本均衡的重要性：
   SMOTE 过采样使小样本类别召回率提升约 15%，但需注意仅对训练集使用，避免测试集数据泄露。

4. 可优化方向：

   • 特征工程：增加交互特征（如 “硅 / 铝比值”），可能提升分类效果；
   • 模型融合：将 RF 与 XGBoost 的预测结果加权融合，进一步提高准确率；
   • 超参数调优：使用贝叶斯优化替代网格搜索，减少调参时间。

五、项目代码与工具

本文完整代码已整理为两个核心文件：

• mineral_classification.py：主程序（数据预处理、模型训练、评估）；
• fill_data.py：缺失值填充工具函数（6 种方法封装）。

如需复现，只需替换矿物数据.xls为自己的数据集，并根据特征维度调整神经网络输入层大小即可。