当前位置：首页 > news >正文

Kaggle铜牌攻略：从泰坦尼克到房价预测，数据科学竞赛完整流程解析

news 2025/9/17 8:31:12

点击 “AladdinEdu，同学们用得起的【H卡】算力平台”，注册即送-H卡级别算力，80G大显存，按量计费，灵活弹性，顶级配置，学生更享专属优惠。

引言：从零开始你的Kaggle竞赛之旅

Kaggle作为全球最大的数据科学竞赛平台，是每个数据科学学习者必须掌握的实战场地。无论是经典的泰坦尼克生存预测，还是更具挑战性的房价预测，这些竞赛都为我们提供了完美的学习场景。本文将带你完整走遍数据科学竞赛的全流程，从数据探索到模型集成，并使用GPU加速技术提升你的工作效率。

无论你是完全没有竞赛经验的新手，还是希望系统提升竞赛技能的学习者，这篇指南都将为你提供从入门到铜牌水平的完整路线图。我们将使用现代工具链，包括GPU加速的cuDF、强大的LightGBM/XGBoost，以及简单的神经网络模型。

1. 环境配置与工具准备

1.1 基础环境搭建

首先，我们需要配置一个高效的竞赛环境：

# 创建conda环境
conda create -n kaggle-competition python=3.8
conda activate kaggle-competition# 安装核心库
pip install cudf-cu11 cuml-cu11 --extra-index-url=https://pypi.nvidia.com
pip install lightgbm xgboost
pip install scikit-learn pandas matplotlib seaborn
pip install jupyter notebook# 安装深度学习框架
pip install torch torchvision torchaudio
pip install tensorflow# 安装Kaggle API
pip install kaggle

1.2 GPU环境验证

确保你的GPU环境正确配置：

import torch
import cudf
import cuml
from cuml.ensemble import RandomForestRegressor# 检查GPU可用性
print(f"PyTorch GPU可用: {torch.cuda.is_available()}")
print(f"CUDA设备数量: {torch.cuda.device_count()}")
if torch.cuda.is_available():print(f"当前GPU: {torch.cuda.get_device_name(0)}")# 检查RAPIDS可用性
df = cudf.DataFrame({'a': [1, 2, 3], 'b': [4, 5, 6]})
print(f"cuDF测试成功: {df.shape}")print("环境配置完成！")

2. 数据获取与探索性分析(EDA)

2.1 使用Kaggle API获取数据

import os
import zipfile
from kaggle.api.kaggle_api_extended import KaggleApidef download_kaggle_dataset(competition_name, path='./data'):"""下载Kaggle竞赛数据集"""if not os.path.exists(path):os.makedirs(path)# 设置Kaggle API凭证os.environ['KAGGLE_CONFIG_DIR'] = os.path.expanduser('~/.kaggle')# 初始化APIapi = KaggleApi()api.authenticate()# 下载数据api.competition_download_files(competition_name, path=path)# 解压文件zip_path = os.path.join(path, f"{competition_name}.zip")with zipfile.ZipFile(zip_path, 'r') as zip_ref:zip_ref.extractall(path)print(f"数据集已下载到: {path}")# 下载泰坦尼克数据集
download_kaggle_dataset('titanic', './data/titanic')# 下载房价预测数据集
download_kaggle_dataset('house-prices-advanced-regression-techniques', './data/house-prices')

2.2 使用cuDF进行高效EDA

import cudf
import matplotlib.pyplot as plt
import seaborn as sns
from matplotlib import rcParams# 设置中文字体和样式
rcParams['font.sans-serif'] = ['SimHei']
rcParams['axes.unicode_minus'] = False
plt.style.use('seaborn-v0_8')def comprehensive_eda(file_path, target_column=None):"""全面的探索性数据分析"""# 读取数据if file_path.endswith('.csv'):df = cudf.read_csv(file_path)else:raise ValueError("仅支持CSV文件")print("=" * 50)print("数据概览")print("=" * 50)print(f"数据集形状: {df.shape}")print(f"行数: {len(df)}")print(f"列数: {len(df.columns)}")# 显示前5行数据print("\n前5行数据:")print(df.head().to_pandas())# 数据类型信息print("\n数据类型信息:")print(df.dtypes)# 缺失值分析print("\n缺失值分析:")missing_info = df.isnull().sum().to_pandas()missing_percentage = (missing_info / len(df)) * 100missing_df = cudf.DataFrame({'缺失值数量': missing_info,'缺失比例(%)': missing_percentage})print(missing_df.to_pandas())# 数值型数据描述性统计numeric_cols = df.select_dtypes(include=['number']).columnsif len(numeric_cols) > 0:print("\n数值型变量描述性统计:")print(df[numeric_cols].describe().to_pandas())# 类别型数据描述性统计categorical_cols = df.select_dtypes(include=['object']).columnsif len(categorical_cols) > 0:print("\n类别型变量描述性统计:")for col in categorical_cols:print(f"\n{col}的唯一值数量: {df[col].nunique()}")print(f"前10个最常见值:")print(df[col].value_counts().head(10).to_pandas())# 可视化分析if target_column and target_column in df.columns:visualize_data(df, target_column)return dfdef visualize_data(df, target_column):"""数据可视化"""# 目标变量分布plt.figure(figsize=(15, 10))# 数值型目标变量if df[target_column].dtype in ['int64', 'float64']:plt.subplot(2, 2, 1)sns.histplot(df[target_column].to_pandas(), kde=True)plt.title(f'{target_column}分布')# 箱线图plt.subplot(2, 2, 2)sns.boxplot(y=df[target_column].to_pandas())plt.title(f'{target_column}箱线图')# 类别型目标变量else:plt.subplot(2, 2, 1)df[target_column].value_counts().plot(kind='bar')plt.title(f'{target_column}分布')plt.xticks(rotation=45)# 相关性热力图（数值型变量）numeric_cols = df.select_dtypes(include=['number']).columnsif len(numeric_cols) > 1:plt.subplot(2, 2, 3)corr_matrix = df[numeric_cols].to_pandas().corr()sns.heatmap(corr_matrix, annot=True, cmap='coolwarm', center=0)plt.title('相关性热力图')plt.tight_layout()plt.savefig('eda_visualization.png', dpi=300, bbox_inches='tight')plt.show()# 对泰坦尼克数据集进行EDA
titanic_df = comprehensive_eda('./data/titanic/train.csv', 'Survived')# 对房价数据集进行EDA
house_df = comprehensive_eda('./data/house-prices/train.csv', 'SalePrice')

3. 特征工程与数据预处理

3.1 自动化特征工程管道

from cuml.preprocessing import LabelEncoder
from sklearn.preprocessing import StandardScaler, MinMaxScaler
import numpy as npclass FeatureEngineer:"""特征工程自动化管道"""def __init__(self, target_column):self.target_column = target_columnself.label_encoders = {}self.scalers = {}self.imputation_values = {}self.selected_features = []def preprocess_data(self, df, is_train=True):"""数据预处理主函数"""# 创建数据副本processed_df = df.copy()# 分离特征和目标if self.target_column in processed_df.columns:y = processed_df[self.target_column]processed_df = processed_df.drop(columns=[self.target_column])else:y = None# 处理缺失值processed_df = self.handle_missing_values(processed_df, is_train)# 编码分类变量processed_df = self.encode_categorical(processed_df, is_train)# 特征缩放processed_df = self.scale_features(processed_df, is_train)# 特征选择（仅在训练时）if is_train:processed_df = self.select_features(processed_df, y)# 重新添加目标变量if y is not None:processed_df[self.target_column] = yreturn processed_dfdef handle_missing_values(self, df, is_train):"""处理缺失值"""for col in df.columns:if df[col].dtype in ['int64', 'float64']:# 数值型变量用中位数填充if is_train:fill_value = df[col].median()self.imputation_values[col] = fill_valueelse:fill_value = self.imputation_values.get(col, 0)df[col] = df[col].fillna(fill_value)else:# 类别型变量用众数填充if is_train:fill_value = df[col].mode()[0] if len(df[col].mode()) > 0 else 'Unknown'self.imputation_values[col] = fill_valueelse:fill_value = self.imputation_values.get(col, 'Unknown')df[col] = df[col].fillna(fill_value)return dfdef encode_categorical(self, df, is_train):"""编码分类变量"""for col in df.columns:if df[col].dtype == 'object':if is_train:le = LabelEncoder()df[col] = le.fit_transform(df[col])self.label_encoders[col] = leelse:le = self.label_encoders.get(col)if le is not None:# 处理未见过的类别unseen_mask = ~df[col].isin(le.classes_)if unseen_mask.any():df[col] = df[col].astype('str')df[col] = df[col].where(~unseen_mask, 'Unknown')df[col] = le.transform(df[col])return dfdef scale_features(self, df, is_train):"""特征缩放"""numeric_cols = df.select_dtypes(include=['int64', 'float64']).columnsfor col in numeric_cols:if is_train:scaler = StandardScaler()scaled_values = scaler.fit_transform(df[col].to_array().reshape(-1, 1))self.scalers[col] = scalerelse:scaler = self.scalers.get(col)if scaler is not None:scaled_values = scaler.transform(df[col].to_array().reshape(-1, 1))df[col] = scaled_values.flatten()return dfdef select_features(self, df, y):"""特征选择"""# 计算与目标变量的相关性numeric_cols = df.select_dtypes(include=['int64', 'float64']).columnscorrelations = {}for col in numeric_cols:if col != self.target_column:corr = abs(df[col].corr(y))correlations[col] = corr# 选择相关性较高的特征sorted_correlations = sorted(correlations.items(), key=lambda x: x[1], reverse=True)self.selected_features = [col for col, corr in sorted_correlations[:20]]  # 选择前20个特征return df[self.selected_features]# 使用特征工程管道
# 泰坦尼克数据集
titanic_engineer = FeatureEngineer('Survived')
titanic_train_processed = titanic_engineer.preprocess_data(titanic_df, is_train=True)# 房价数据集
house_engineer = FeatureEngineer('SalePrice')
house_train_processed = house_engineer.preprocess_data(house_df, is_train=True)

3.2 高级特征工程技巧

def create_advanced_features(df, target_column=None):"""创建高级特征"""advanced_df = df.copy()# 数值型特征的多项式特征numeric_cols = advanced_df.select_dtypes(include=['int64', 'float64']).columnsif target_column and target_column in numeric_cols:numeric_cols = numeric_cols.drop(target_column)# 创建多项式特征for i, col1 in enumerate(numeric_cols):for col2 in numeric_cols[i+1:]:advanced_df[f'{col1}_times_{col2}'] = advanced_df[col1] * advanced_df[col2]advanced_df[f'{col1}_div_{col2}'] = advanced_df[col1] / (advanced_df[col2] + 1e-5)# 创建统计特征advanced_df['numeric_mean'] = advanced_df[numeric_cols].mean(axis=1)advanced_df['numeric_std'] = advanced_df[numeric_cols].std(axis=1)advanced_df['numeric_max'] = advanced_df[numeric_cols].max(axis=1)# 对数值型特征进行分桶for col in numeric_cols:advanced_df[f'{col}_bin'] = cudf.cut(advanced_df[col], bins=5)return advanced_df# 应用高级特征工程
titanic_advanced = create_advanced_features(titanic_train_processed, 'Survived')
house_advanced = create_advanced_features(house_train_processed, 'SalePrice')

4. 模型训练与优化

4.1 使用LightGBM和XGBoost

import lightgbm as lgb
import xgboost as xgb
from sklearn.model_selection import train_test_split, KFold
from sklearn.metrics import accuracy_score, mean_squared_error
import numpy as npclass ModelTrainer:"""模型训练与优化类"""def __init__(self, target_column, problem_type='classification'):self.target_column = target_columnself.problem_type = problem_typeself.models = {}self.best_params = {}def prepare_data(self, df):"""准备训练数据"""X = df.drop(columns=[self.target_column])y = df[self.target_column]return X, ydef train_lightgbm(self, X, y, params=None):"""训练LightGBM模型"""if params is None:params = {'objective': 'binary' if self.problem_type == 'classification' else 'regression','metric': 'binary_error' if self.problem_type == 'classification' else 'rmse','boosting_type': 'gbdt','num_leaves': 31,'learning_rate': 0.05,'feature_fraction': 0.9,'bagging_fraction': 0.8,'bagging_freq': 5,'verbose': -1}# 转换数据为LightGBM格式if isinstance(X, cudf.DataFrame):X = X.to_pandas()if isinstance(y, cudf.Series):y = y.to_pandas()X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=42)train_data = lgb.Dataset(X_train, label=y_train)val_data = lgb.Dataset(X_val, label=y_val, reference=train_data)# 训练模型model = lgb.train(params,train_data,num_boost_round=1000,valid_sets=[val_data],callbacks=[lgb.early_stopping(stopping_rounds=50), lgb.log_evaluation(100)])self.models['lightgbm'] = modelreturn modeldef train_xgboost(self, X, y, params=None):"""训练XGBoost模型"""if params is None:params = {'objective': 'binary:logistic' if self.problem_type == 'classification' else 'reg:squarederror','eval_metric': 'error' if self.problem_type == 'classification' else 'rmse','max_depth': 6,'learning_rate': 0.1,'subsample': 0.8,'colsample_bytree': 0.8,'random_state': 42}if isinstance(X, cudf.DataFrame):X = X.to_pandas()if isinstance(y, cudf.Series):y = y.to_pandas()X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=42)dtrain = xgb.DMatrix(X_train, label=y_train)dval = xgb.DMatrix(X_val, label=y_val)model = xgb.train(params,dtrain,num_boost_round=1000,evals=[(dval, 'validation')],early_stopping_rounds=50,verbose_eval=100)self.models['xgboost'] = modelreturn modeldef cross_validate(self, X, y, model_type='lightgbm', n_splits=5):"""交叉验证"""if isinstance(X, cudf.DataFrame):X = X.to_pandas()if isinstance(y, cudf.Series):y = y.to_pandas()kf = KFold(n_splits=n_splits, shuffle=True, random_state=42)scores = []for train_index, val_index in kf.split(X):X_train, X_val = X.iloc[train_index], X.iloc[val_index]y_train, y_val = y.iloc[train_index], y.iloc[val_index]if model_type == 'lightgbm':train_data = lgb.Dataset(X_train, label=y_train)val_data = lgb.Dataset(X_val, label=y_val)model = lgb.train({'objective': 'binary' if self.problem_type == 'classification' else 'regression'},train_data,num_boost_round=100,valid_sets=[val_data],verbose_eval=False)preds = model.predict(X_val)elif model_type == 'xgboost':dtrain = xgb.DMatrix(X_train, label=y_train)dval = xgb.DMatrix(X_val, label=y_val)model = xgb.train({'objective': 'binary:logistic' if self.problem_type == 'classification' else 'reg:squarederror'},dtrain,num_boost_round=100)preds = model.predict(dval)if self.problem_type == 'classification':preds_binary = (preds > 0.5).astype(int)score = accuracy_score(y_val, preds_binary)else:score = np.sqrt(mean_squared_error(y_val, preds))scores.append(score)return np.mean(scores), np.std(scores)# 训练泰坦尼克模型
titanic_trainer = ModelTrainer('Survived', 'classification')
X_titanic, y_titanic = titanic_trainer.prepare_data(titanic_advanced)# 训练LightGBM模型
lgb_model = titanic_trainer.train_lightgbm(X_titanic, y_titanic)# 训练XGBoost模型
xgb_model = titanic_trainer.train_xgboost(X_titanic, y_titanic)# 交叉验证
lgb_score, lgb_std = titanic_trainer.cross_validate(X_titanic, y_titanic, 'lightgbm')
xgb_score, xgb_std = titanic_trainer.cross_validate(X_titanic, y_titanic, 'xgboost')print(f"LightGBM交叉验证得分: {lgb_score:.4f} ± {lgb_std:.4f}")
print(f"XGBoost交叉验证得分: {xgb_score:.4f} ± {xgb_std:.4f}")

4.2 神经网络模型

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDatasetclass TabularNN(nn.Module):"""用于表格数据的神经网络"""def __init__(self, input_size, output_size=1, hidden_layers=[64, 32], dropout=0.2):super(TabularNN, self).__init__()layers = []prev_size = input_sizefor hidden_size in hidden_layers:layers.append(nn.Linear(prev_size, hidden_size))layers.append(nn.ReLU())layers.append(nn.BatchNorm1d(hidden_size))layers.append(nn.Dropout(dropout))prev_size = hidden_sizelayers.append(nn.Linear(prev_size, output_size))if output_size == 1:layers.append(nn.Sigmoid())self.network = nn.Sequential(*layers)def forward(self, x):return self.network(x)def train_neural_network(X, y, problem_type='classification', epochs=100):"""训练神经网络"""# 转换数据为PyTorch张量if isinstance(X, cudf.DataFrame):X = torch.FloatTensor(X.to_pandas().values)else:X = torch.FloatTensor(X.values)if isinstance(y, cudf.Series):y = torch.FloatTensor(y.to_pandas().values)else:y = torch.FloatTensor(y.values)if problem_type == 'classification':output_size = 1else:output_size = 1# 创建数据集和数据加载器dataset = TensorDataset(X, y)dataloader = DataLoader(dataset, batch_size=32, shuffle=True)# 创建模型model = TabularNN(X.shape[1], output_size)criterion = nn.BCELoss() if problem_type == 'classification' else nn.MSELoss()optimizer = optim.Adam(model.parameters(), lr=0.001)# 训练循环model.train()for epoch in range(epochs):epoch_loss = 0for batch_X, batch_y in dataloader:optimizer.zero_grad()outputs = model(batch_X).squeeze()loss = criterion(outputs, batch_y)loss.backward()optimizer.step()epoch_loss += loss.item()if (epoch + 1) % 10 == 0:print(f'Epoch [{epoch+1}/{epochs}], Loss: {epoch_loss/len(dataloader):.4f}')return model# 训练泰坦尼克神经网络模型
nn_model = train_neural_network(X_titanic, y_titanic, 'classification', epochs=100)

5. 模型集成与提交

5.1 模型集成策略

class EnsembleModel:"""模型集成类"""def __init__(self, models, weights=None):self.models = modelsself.weights = weights if weights else [1/len(models)] * len(models)def predict(self, X):"""集成预测"""predictions = []for model in self.models:if hasattr(model, 'predict'):  # scikit-learn风格模型pred = model.predict(X)elif hasattr(model, 'predict_proba'):  # 概率预测pred = model.predict_proba(X)[:, 1]else:  # 其他模型if isinstance(X, cudf.DataFrame):X_df = X.to_pandas()else:X_df = Xif hasattr(model, 'booster_'):  # LightGBMpred = model.predict(X_df)else:  # 神经网络with torch.no_grad():X_tensor = torch.FloatTensor(X_df.values)pred = model(X_tensor).numpy().flatten()predictions.append(pred)# 加权平均weighted_sum = np.zeros_like(predictions[0])for pred, weight in zip(predictions, self.weights):weighted_sum += pred * weightreturn weighted_sum# 创建集成模型
ensemble = EnsembleModel(models=[lgb_model, xgb_model, nn_model],weights=[0.4, 0.4, 0.2]  # 根据交叉验证性能调整权重
)

5.2 生成提交文件

def create_submission_file(model, test_df, sample_submission_path, output_path):"""创建Kaggle提交文件"""# 读取测试数据test_df_processed = titanic_engineer.preprocess_data(test_df, is_train=False)# 进行预测if isinstance(test_df_processed, cudf.DataFrame):X_test = test_df_processed.to_pandas()else:X_test = test_df_processedpredictions = model.predict(X_test)# 二分类问题需要转换概率为类别if len(np.unique(predictions)) > 2:  # 回归问题submission_df = cudf.DataFrame({'Id': test_df['PassengerId'],'SalePrice': predictions})else:  # 分类问题binary_predictions = (predictions > 0.5).astype(int)submission_df = cudf.DataFrame({'PassengerId': test_df['PassengerId'],'Survived': binary_predictions})# 保存提交文件submission_df.to_csv(output_path, index=False)print(f"提交文件已保存到: {output_path}")return submission_df# 读取测试数据
titanic_test = cudf.read_csv('./data/titanic/test.csv')# 生成泰坦尼克预测结果
titanic_submission = create_submission_file(ensemble,titanic_test,'./data/titanic/gender_submission.csv','titanic_submission.csv'
)# 房价预测的提交（类似流程）
house_test = cudf.read_csv('./data/house-prices/test.csv')
house_submission = create_submission_file(ensemble,  # 需要先训练房价预测模型house_test,'./data/house-prices/sample_submission.csv','house_submission.csv'
)

6. 进阶技巧与优化策略

6.1 超参数优化

from sklearn.model_selection import GridSearchCV
import warnings
warnings.filterwarnings('ignore')def optimize_hyperparameters(X, y, model_type='lightgbm'):"""超参数优化"""if isinstance(X, cudf.DataFrame):X = X.to_pandas()if isinstance(y, cudf.Series):y = y.to_pandas()if model_type == 'lightgbm':param_grid = {'num_leaves': [31, 63, 127],'learning_rate': [0.01, 0.05, 0.1],'feature_fraction': [0.8, 0.9, 1.0],'bagging_fraction': [0.8, 0.9, 1.0]}model = lgb.LGBMClassifier(objective='binary', n_estimators=100)elif model_type == 'xgboost':param_grid = {'max_depth': [3, 6, 9],'learning_rate': [0.01, 0.05, 0.1],'subsample': [0.8, 0.9, 1.0],'colsample_bytree': [0.8, 0.9, 1.0]}model = xgb.XGBClassifier(objective='binary:logistic', n_estimators=100)# 使用网格搜索grid_search = GridSearchCV(model,param_grid,cv=3,scoring='accuracy',n_jobs=-1,verbose=1)grid_search.fit(X, y)print(f"最佳参数: {grid_search.best_params_}")print(f"最佳得分: {grid_search.best_score_:.4f}")return grid_search.best_estimator_# 优化LightGBM超参数
best_lgb = optimize_hyperparameters(X_titanic, y_titanic, 'lightgbm')

6.2 特征重要性分析

def analyze_feature_importance(model, feature_names, top_n=20):"""分析特征重要性"""if hasattr(model, 'feature_importances_'):# scikit-learn风格模型importances = model.feature_importances_elif hasattr(model, 'feature_importance'):# LightGBM模型importances = model.feature_importance()else:print("该模型不支持特征重要性分析")return# 创建特征重要性DataFrameimportance_df = cudf.DataFrame({'feature': feature_names,'importance': importances})# 排序并选择前N个特征importance_df = importance_df.sort_values('importance', ascending=False).head(top_n)# 可视化plt.figure(figsize=(12, 8))plt.barh(range(len(importance_df)), importance_df['importance'].to_pandas())plt.yticks(range(len(importance_df)), importance_df['feature'].to_pandas())plt.xlabel('特征重要性')plt.title('Top特征重要性')plt.gca().invert_yaxis()plt.tight_layout()plt.savefig('feature_importance.png', dpi=300, bbox_inches='tight')plt.show()return importance_df# 分析特征重要性
feature_importance = analyze_feature_importance(lgb_model, X_titanic.columns)