kaggle泰坦尼克号人员生还预测
自行学习参考如何使用kaggle平台，写下使用注意点，并对下述比赛提交代码
kaggle泰坦尼克号人员生还预测
import pandas as pd
train_data=pd.read_csv('train.csv')
test_data=pd.read_csv('test.csv')
train_data.head()
train_data.info()
train_data.head()
train_data.info()
train_data.isnull().sum()
#Age列中存在空值，用该列的中位数填充
train_data['Age'].fillna(train_data['Age'].median(), inplace=True)
#将Embarked列中的空值用S填充
train_data['Embarked'].fillna(train_data['Embarked'].mode()[0], inplace=True)
#删除Cabin列,因为该列中存在大量空值
train_data.drop(columns=['Cabin'], inplace=True)
train_data.isnull().sum()
test_data.isnull().sum()
#Age列中存在空值，用该列的中位数填充
test_data['Age'].fillna(test_data['Age'].median(), inplace=True)
#将Embarked列中的空值用S填充
test_data['Fare'].fillna(test_data['Fare'].median(), inplace=True)
#删除Cabin列,因为该列中存在大量空值
test_data.drop(columns=['Cabin'], inplace=True)
test_data.isnull().sum()
for discrete_features in train_data.columns:
if train_data[discrete_features].dtype == 'object':
print(discrete_features)
mapping={'male':0, 'female':1}
train_data['Sex']=train_data['Sex'].map(mapping)
train_data['Sex'].value_counts()
mapping={'S':2, 'C':1, 'Q':0}
train_data['Embarked']=train_data['Embarked'].map(mapping)
train_data['Embarked'].value_counts()
for discrete_features in test_data.columns:
if test_data[discrete_features].dtype == 'object':
print(discrete_features)
mapping={'male':0, 'female':1}
test_data['Sex']=test_data['Sex'].map(mapping)
test_data['Sex'].value_counts()
mapping={'S':2, 'C':1, 'Q':0}
test_data['Embarked']=test_data['Embarked'].map(mapping)
test_data['Embarked'].value_counts()
drop_cols = ["Name", "Ticket", "PassengerId"]
train_data= train_data.drop(columns=drop_cols)from sklearn.model_selection import train_test_split
X = train_data.drop(['Survived'], axis=1) # 特征，axis=1表示按列删除
y = train_data['Survived'] # 标签
# # 按照8:2划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) # 80%训练集，20%测试集
from sklearn.ensemble import RandomForestClassifier #随机森林分类器
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score # 用于评估分类器性能的指标
from sklearn.metrics import classification_report, confusion_matrix #用于生成分类报告和混淆矩阵
import warnings #用于忽略警告信息
warnings.filterwarnings("ignore") # 忽略所有警告信息
# --- 1. 默认参数的随机森林 ---
print("--- 1. 默认参数随机森林 (训练集 -> 测试集) ---")
import time
start_time = time.time() # 记录开始时间
rf_model = RandomForestClassifier(random_state=42)
rf_model.fit(X_train, y_train) # 在训练集上训练
rf_pred = rf_model.predict(X_test) # 在测试集上预测
end_time = time.time() # 记录结束时间
print(f"训练与预测耗时: {end_time - start_time:.4f} 秒")
print("\n默认随机森林 在测试集上的分类报告：")
print(classification_report(y_test, rf_pred))
print("默认随机森林 在测试集上的混淆矩阵：")
print(confusion_matrix(y_test, rf_pred))
rf_accuracy = accuracy_score(y_test, rf_pred)
rf_precision = precision_score(y_test, rf_pred)
rf_recall = recall_score(y_test, rf_pred)
rf_f1 = f1_score(y_test, rf_pred)
print("随机森林 模型评估指标：")
print(f"准确率: {rf_accuracy:.4f}")
print(f"精确率: {rf_precision:.4f}")
print(f"召回率: {rf_recall:.4f}")
print(f"F1 值: {rf_f1:.4f}")--- 1. 默认参数随机森林 (训练集 -> 测试集) ---
训练与预测耗时: 0.1203 秒
默认随机森林 在测试集上的分类报告：
precision recall f1-score support
0 0.83 0.87 0.85 105
1 0.80 0.76 0.78 74
accuracy 0.82 179
macro avg 0.82 0.81 0.81 179
weighted avg 0.82 0.82 0.82 179
默认随机森林 在测试集上的混淆矩阵：
[[91 14]
[18 56]]
随机森林 模型评估指标：
准确率: 0.8212
精确率: 0.8000
召回率: 0.7568
F1 值: 0.7778# --- 2. 网格搜索优化随机森林 ---
print("\n--- 2. 网格搜索优化随机森林 (训练集 -> 测试集) ---")
from sklearn.model_selection import GridSearchCV
# 定义要搜索的参数网格
param_grid = {
'n_estimators': [50, 100, 200],
'max_depth': [None, 10, 20, 30],
'min_samples_split': [2, 5, 10],
'min_samples_leaf': [1, 2, 4]
}
# 创建网格搜索对象
grid_search = GridSearchCV(estimator=RandomForestClassifier(random_state=42), # 随机森林分类器
param_grid=param_grid, # 参数网格
cv=5, # 5折交叉验证
n_jobs=-1, # 使用所有可用的CPU核心进行并行计算
scoring='accuracy') # 使用准确率作为评分标准
start_time = time.time()
# 在训练集上进行网格搜索
grid_search.fit(X_train, y_train) # 在训练集上训练，模型实例化和训练的方法都被封装在这个网格搜索对象里了
end_time = time.time()
print(f"网格搜索耗时: {end_time - start_time:.4f} 秒")
print("最佳参数: ", grid_search.best_params_) #best_params_属性返回最佳参数组合
# 使用最佳参数的模型进行预测
best_model = grid_search.best_estimator_ # 获取最佳模型
best_pred = best_model.predict(X_test) # 在测试集上进行预测
print("\n网格搜索优化后的随机森林 在测试集上的分类报告：")
print(classification_report(y_test, best_pred))
print("网格搜索优化后的随机森林 在测试集上的混淆矩阵：")
print(confusion_matrix(y_test, best_pred))--- 2. 网格搜索优化随机森林 (训练集 -> 测试集) ---
网格搜索耗时: 21.2556 秒
最佳参数: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 5, 'n_estimators': 100}
网格搜索优化后的随机森林 在测试集上的分类报告：
precision recall f1-score support
0 0.82 0.90 0.86 105
1 0.83 0.73 0.78 74
accuracy 0.83 179
macro avg 0.83 0.81 0.82 179
weighted avg 0.83 0.83 0.82 179
网格搜索优化后的随机森林 在测试集上的混淆矩阵：
[[94 11]
[20 54]]import numpy as np # 引入 numpy 用于计算平均值等
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import StratifiedKFold, cross_validate # 引入分层 K 折和交叉验证工具
from sklearn.metrics import make_scorer, accuracy_score, precision_score, recall_score, f1_score, confusion_matrix, classification_report
import time
import warnings
warnings.filterwarnings("ignore")
# --- 1. 默认参数的随机森林 (原始代码，作为对比基准) ---
print("--- 1. 默认参数随机森林 (训练集 -> 测试集) ---")
start_time = time.time()
rf_model_default = RandomForestClassifier(random_state=42)
rf_model_default.fit(X_train, y_train)
rf_pred_default = rf_model_default.predict(X_test)
end_time = time.time()
print(f"默认模型训练与预测耗时: {end_time - start_time:.4f} 秒")
print("\n默认随机森林 在测试集上的分类报告：")
print(classification_report(y_test, rf_pred_default))
print("默认随机森林 在测试集上的混淆矩阵：")
print(confusion_matrix(y_test, rf_pred_default))
print("-" * 50)
# --- 2. 带权重的随机森林 + 交叉验证 (在训练集上进行CV) ---
print("--- 2. 带权重随机森林 + 交叉验证 (在训练集上进行) ---")
# 确定少数类标签 (非常重要！)
# 假设是二分类问题，我们需要知道哪个是少数类标签才能正确解读 recall, precision, f1
# 例如，如果标签是 0 和 1，可以这样查看：
counts = np.bincount(y_train)
minority_label = np.argmin(counts) # 找到计数最少的类别的标签
majority_label = np.argmax(counts)
print(f"训练集中各类别数量: {counts}")
print(f"少数类标签: {minority_label}, 多数类标签: {majority_label}")
# 定义带权重的模型
rf_model_weighted = RandomForestClassifier(
random_state=42,
class_weight='balanced' # 关键：自动根据类别频率调整权重
# class_weight={minority_label: 10, majority_label: 1} # 或者可以手动设置权重字典
)
# 设置交叉验证策略 (使用 StratifiedKFold 保证每折类别比例相似)
cv_strategy = StratifiedKFold(n_splits=5, shuffle=True, random_state=42) # 5折交叉验证
# 定义用于交叉验证的评估指标
# 特别关注少数类的指标，使用 make_scorer 指定 pos_label
# 注意：如果你的少数类标签不是 1，需要修改 pos_label
scoring = {
'accuracy': 'accuracy',
'precision_minority': make_scorer(precision_score, pos_label=minority_label, zero_division=0),
'recall_minority': make_scorer(recall_score, pos_label=minority_label),
'f1_minority': make_scorer(f1_score, pos_label=minority_label)
}
print(f"开始进行 {cv_strategy.get_n_splits()} 折交叉验证...")
start_time_cv = time.time()
# 执行交叉验证 (在 X_train, y_train 上进行)
# cross_validate 会自动完成训练和评估过程
cv_results = cross_validate(
estimator=rf_model_weighted,
X=X_train,
y=y_train,
cv=cv_strategy,
scoring=scoring,
n_jobs=-1, # 使用所有可用的 CPU 核心
return_train_score=False # 通常我们更关心测试折的得分
)
end_time_cv = time.time()
print(f"交叉验证耗时: {end_time_cv - start_time_cv:.4f} 秒")
# 打印交叉验证结果的平均值
print("\n带权重随机森林 交叉验证平均性能 (基于训练集划分)：")
for metric_name, scores in cv_results.items():
if metric_name.startswith('test_'): # 我们关心的是在验证折上的表现
# 提取指标名称（去掉 'test_' 前缀）
clean_metric_name = metric_name.split('test_')[1]
print(f" 平均 {clean_metric_name}: {np.mean(scores):.4f} (+/- {np.std(scores):.4f})")
print("-" * 50)
# --- 3. 使用权重训练最终模型，并在测试集上评估 ---
print("--- 3. 训练最终的带权重模型 (整个训练集) 并在测试集上评估 ---")
start_time_final = time.time()
# 使用与交叉验证中相同的设置来训练最终模型
rf_model_weighted_final = RandomForestClassifier(
random_state=42,
class_weight='balanced'
)
rf_model_weighted_final.fit(X_train, y_train) # 在整个训练集上训练
rf_pred_weighted = rf_model_weighted_final.predict(X_test) # 在测试集上预测
end_time_final = time.time()
print(f"最终带权重模型训练与预测耗时: {end_time_final - start_time_final:.4f} 秒")
print("\n带权重随机森林 在测试集上的分类报告：")
# 确保 classification_report 也关注少数类 (可以通过 target_names 参数指定标签名称)
# 或者直接查看报告中少数类标签对应的行
print(classification_report(y_test, rf_pred_weighted)) # , target_names=[f'Class {majority_label}', f'Class {minority_label}'] 如果需要指定名称
print("带权重随机森林 在测试集上的混淆矩阵：")
print(confusion_matrix(y_test, rf_pred_weighted))
print("-" * 50)
# 对比总结 (简单示例)
print("性能对比 (测试集上的少数类召回率 Recall):")
recall_default = recall_score(y_test, rf_pred_default, pos_label=minority_label)
recall_weighted = recall_score(y_test, rf_pred_weighted, pos_label=minority_label)
print(f" 默认模型: {recall_default:.4f}")
print(f" 带权重模型: {recall_weighted:.4f}")
--- 1. 默认参数随机森林 (训练集 -> 测试集) ---
默认模型训练与预测耗时: 0.1105 秒
默认随机森林 在测试集上的分类报告：
precision recall f1-score support
0 0.83 0.87 0.85 105
1 0.80 0.76 0.78 74
accuracy 0.82 179
macro avg 0.82 0.81 0.81 179
weighted avg 0.82 0.82 0.82 179
默认随机森林 在测试集上的混淆矩阵：
[[91 14]
[18 56]]
--------------------------------------------------
--- 2. 带权重随机森林 + 交叉验证 (在训练集上进行) ---
训练集中各类别数量: [444 268]
少数类标签: 1, 多数类标签: 0
开始进行 5 折交叉验证...
交叉验证耗时: 0.1893 秒
带权重随机森林 交叉验证平均性能 (基于训练集划分)：
平均 accuracy: 0.7963 (+/- 0.0249)
平均 precision_minority: 0.7474 (+/- 0.0324)
平均 recall_minority: 0.6941 (+/- 0.0551)
平均 f1_minority: 0.7188 (+/- 0.0385)
--------------------------------------------------
--- 3. 训练最终的带权重模型 (整个训练集) 并在测试集上评估 ---
最终带权重模型训练与预测耗时: 0.1058 秒
带权重随机森林 在测试集上的分类报告：
precision recall f1-score support
0 0.83 0.86 0.85 105
1 0.79 0.76 0.77 74
accuracy 0.82 179
macro avg 0.81 0.81 0.81 179
weighted avg 0.81 0.82 0.82 179
带权重随机森林 在测试集上的混淆矩阵：
[[90 15]
[18 56]]
--------------------------------------------------
性能对比 (测试集上的少数类召回率 Recall):
默认模型: 0.7568
带权重模型: 0.7568final_model = RandomForestClassifier(
random_state=42,
class_weight='balanced',
max_depth=10, # 可选：你调参得到的最佳参数
min_samples_leaf=1,
min_samples_split=10,
n_estimators=50
)
final_model.fit(X_train, y_train)
final_predictions = final_model.predict(X_test) # 预测 test.csv 的样本@浙大疏锦行