admin/TWBG_Materials
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

backup materials and knowledge-base docs

Browse Source
This commit is contained in:
admin
2026-05-30 16:22:29 +08:00
commit 93e50e8fce
3024 changed files with 2994945 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
文档润色流和知识库构建流/claude-scholar/skills/kaggle-learner/references/knowledge/.archive/cv.md Normal file
View File

@@ -0,0 +1,17 @@
# CV Knowledge Base
> Last updated: 2026-01-21
> Source count: 0
## Original Summaries
_No sources yet._
## Code Templates
_No templates yet._
## Best Practices
_No practices yet._
## Metadata
| Source | Date | Tags |
|--------|------|------|

17
文档润色流和知识库构建流/claude-scholar/skills/kaggle-learner/references/knowledge/.archive/multimodal.md Normal file
View File

@@ -0,0 +1,17 @@
# Multimodal Knowledge Base
> Last updated: 2026-01-21
> Source count: 0
## Original Summaries
_No sources yet._
## Code Templates
_No templates yet._
## Best Practices
_No practices yet._
## Metadata
| Source | Date | Tags |
|--------|------|------|

3502
文档润色流和知识库构建流/claude-scholar/skills/kaggle-learner/references/knowledge/.archive/nlp.md Normal file
View File

File diff suppressed because it is too large Load Diff

829
文档润色流和知识库构建流/claude-scholar/skills/kaggle-learner/references/knowledge/.archive/tabular.md Normal file
View File

@@ -0,0 +1,829 @@
# Tabular Knowledge Base
> Last updated: 2025-01-22
> Source count: 1
## Original Summaries
### CMI - Problematic Internet Use (2024) - 2025-01-22
**Source:** [Kaggle Competition](https://www.kaggle.com/competitions/child-mind-institute-problematic-internet-use)
**Category:** Tabular (表格数据 + 时序混合)
**Key Techniques:**
- **中间分数预测**：预测 PCIAT-PCIAT_Total 而非直接预测 sii
- **多seed平均**：减少seed引起的方差
- **高fold交叉验证**：10-fold stratified KFold
- **Pseudo Labeling**：填充缺失target
- **GBM主导的集成**：LGBM + XGBoost + CatBoost
- **Tweedie Loss**：处理偏态分布
- **时序特征工程**：k-means聚类
- **特征清洗**：去除异常特征、PCA降维
**Results:** 多seed平均、预测中间分数、Pseudo Labeling 是关键技术
---
## Competition Brief (竞赛简介)
### CMI - Problematic Internet Use (2024)
**竞赛背景：**
- **主办方**：Child Mind Institute
- **目标**：预测儿童和青少年的问题性网络使用严重程度（sii）
- **应用场景**：理解与抑郁和焦虑等心理健康问题相关的网络使用行为
**数据集规模：**
- 总样本数：约 3,900+（训练集）
- 特征：表格数据 + 部分时序数据
- 类别：4 分类（sii = 0, 1, 2, 3）
**数据特点：**
1. **混合数据类型**：表格数据（身体活动、健康指标）+ 时序数据
2. **target 缺失**：训练集中部分样本的 sii 缺失
3. **中间分数**：PCIAT-PCIAT_Total 是 sii 的连续分数版本
4. **类别分布不均**：约 58.3% 为 0 类（无问题）
**评估指标：**
- **Quadratic Weighted Kappa (QWK)**：衡量预测与实际的一致性
- 分数范围：-1 到 1，越高越好
- 特点：对分类错误的惩罚与严重程度成正比
**关键挑战：**
1. **Seed 敏感**：不同 seed 导致 LB 分数剧烈波动
2. **数据泄露**：公开 notebook 泄露了训练数据
3. **LB 不可靠**：Private LB 大幅 shake（波动）
4. **Target 缺失**：需要 Pseudo Labeling 处理
---
## Code Templates
### 中间分数预测 (PCIAT-PCIAT_Total)
**关键洞察：** 预测连续分数比直接预测类别更有效
```python
import numpy as np
import pandas as pd
from lightgbm import LGBMRegressor
from sklearn.model_selection import StratifiedKFold
# 原始 sii 标签: 0, 1, 2, 3
# PCIAT-PCIAT_Total: 连续分数 (0-100)
def train_intermediate_target_model(X_train, y_train_total, X_test):
"""
预测 PCIAT-PCIAT_Total (中间分数)，然后转换为 sii
"""
# 根据 sii 创建分层的 bins
# 这确保每个 fold 中各类别比例一致
train_df = X_train.copy()
train_df['sii'] = (y_train_total > 30).astype(int) + \
(y_train_total > 50).astype(int) + \
(y_train_total > 80).astype(int)
# 10-fold stratified KFold
n_folds = 10
skf = StratifiedKFold(n_splits=n_folds, shuffle=True, random_state=42)
# 存储预测结果
oof_preds = np.zeros(len(X_train))
test_preds = np.zeros(len(X_test))
for fold, (train_idx, val_idx) in enumerate(skf.split(X_train, train_df['sii'])):
X_tr, X_val = X_train.iloc[train_idx], X_train.iloc[val_idx]
y_tr, y_val = y_train_total.iloc[train_idx], y_train_total.iloc[val_idx]
# LightGBM 回归器
model = LGBMRegressor(
n_estimators=1000,
learning_rate=0.05,
num_leaves=31,
max_depth=-1,
random_state=42 + fold # 每个 fold 不同 seed
)
model.fit(X_tr, y_tr, eval_set=[(X_val, y_val)],
early_stopping_rounds=100, verbose=False)
# 预测中间分数
oof_preds[val_idx] = model.predict(X_val)
test_preds += model.predict(X_test) / n_folds
return oof_preds, test_preds
def convert_total_to_sii(pred_total):
"""
将 PCIAT-PCIAT_Total 转换为 sii 标签
阈值: 0-30→0, 31-50→1, 51-80→2, 81-100→3
"""
pred_sii = np.zeros(len(pred_total))
pred_sii[pred_total > 30] = 1
pred_sii[pred_total > 50] = 2
pred_sii[pred_total > 80] = 3
return pred_sii.astype(int)
```
### 多 Seed 平均
**关键洞察：** 多个 seed 平均可以减少预测方差
```python
import numpy as np
from lightgbm import LGBMRegressor
def multi_seed_prediction(X_train, y_train, X_test, seeds=[42, 123, 456, 789, 1011]):
"""
多个 seed 训练模型，取平均预测
"""
test_preds_all = []
for seed in seeds:
model = LGBMRegressor(
n_estimators=1000,
learning_rate=0.05,
random_state=seed
)
model.fit(X_train, y_train)
test_preds_all.append(model.predict(X_test))
# 平均预测
test_preds_mean = np.mean(test_preds_all, axis=0)
return test_preds_mean
# 更进一步：多 fold × 多 seed
def multi_fold_multi_seed(X_train, y_train, X_test, n_folds=5, seeds=10):
"""
多 fold × 多 seed = 更稳定的预测
"""
n_folds = 5
seeds = list(range(10)) # 10 个 seeds
test_preds = []
for seed in seeds:
for fold in range(n_folds):
model = LGBMRegressor(
n_estimators=1000,
random_state=seed + fold * 100
)
# ... train and predict
test_preds.append(model.predict(X_test))
# 50 个模型的平均 (5 folds × 10 seeds)
return np.mean(test_preds, axis=0)
```
### Pseudo Labeling
**关键洞察：** 用模型预测填充缺失的 target
```python
import numpy as np
import pandas as pd
def pseudo_labeling(X_train, y_train, X_missing, n_iterations=3):
"""
Pseudo Labeling 迭代填充缺失 target
"""
# 分割有标签和无标签数据
has_label = ~y_train.isna()
X_labeled = X_train[has_label]
y_labeled = y_train[has_label]
X_unlabeled = X_train[~has_label]
# 初始模型（仅用有标签数据训练）
model = LGBMRegressor(random_state=42)
model.fit(X_labeled, y_labeled)
# 迭代预测和训练
for iteration in range(n_iterations):
# 预测无标签数据
pseudo_labels = model.predict(X_unlabeled)
# 合并有标签和伪标签数据
X_combined = pd.concat([X_labeled, X_unlabeled])
y_combined = pd.concat([y_labeled, pd.Series(pseudo_labels, index=X_unlabeled.index)])
# 重新训练模型
model = LGBMRegressor(random_state=42 + iteration)
model.fit(X_combined, y_combined)
return model
# 注意：CV 计算时不使用 pseudo labels
def cv_with_pseudo(X_train, y_train, X_missing):
"""
交叉验证时不使用 pseudo labels
"""
has_label = ~y_train.isna()
X_labeled = X_train[has_label]
y_labeled = y_train[has_label]
# 训练 pseudo 模型（用于最终预测）
pseudo_model = pseudo_labeling(X_train, y_train, X_missing)
# CV 仅用有标签数据
from sklearn.model_selection import cross_val_score
cv_model = LGBMRegressor(random_state=42)
cv_scores = cross_val_score(cv_model, X_labeled, y_labeled, cv=5)
return pseudo_model, cv_scores
```
### Tweedie Loss
**关键洞察：** 处理偏态分布的目标变量
```python
import lightgbm as lgb
def train_with_tweedie_loss(X_train, y_train, X_val, y_val):
"""
使用 Tweedie Loss 训练 LightGBM
适用于偏态分布（如保险索赔、疾病严重程度）
"""
train_data = lgb.Dataset(X_train, label=y_train)
val_data = lgb.Dataset(X_val, label=y_val, reference=train_data)
params = {
'objective': 'tweedie',
'tweedie_variance_power': 1.5, # 1 < p < 2，控制偏态程度
'metric': 'rmse',
'learning_rate': 0.05,
'num_leaves': 31,
'max_depth': -1,
'verbose': -1
}
model = lgb.train(
params,
train_data,
num_boost_round=1000,
valid_sets=[val_data],
early_stopping_rounds=100,
verbose_eval=False
)
return model
```
### 时序特征 k-means 聚类
**关键洞察：** 将时序数据聚类成类别特征
```python
import numpy as np
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
def extract_time_series_cluster_features(time_series_data, n_clusters=5):
"""
时序数据 k-means 聚类作为特征
"""
# 假设 time_series_data 是 (n_samples, n_timesteps, n_features)
n_samples = time_series_data.shape[0]
# 展平时序数据: (n_samples, n_timesteps * n_features)
ts_flat = time_series_data.reshape(n_samples, -1)
# 标准化
scaler = StandardScaler()
ts_scaled = scaler.fit_transform(ts_flat)
# k-means 聚类
kmeans = KMeans(n_clusters=n_clusters, random_state=42, n_init=10)
cluster_labels = kmeans.fit_predict(ts_scaled)
# 聚类距离作为特征
cluster_distances = kmeans.transform(ts_scaled)
# 创建特征 DataFrame
cluster_features = pd.DataFrame({
f'ts_cluster_dist_{i}': cluster_distances[:, i]
for i in range(n_clusters)
})
cluster_features['ts_cluster_label'] = cluster_labels
return cluster_features
# 使用示例
# time_series_data 是原始时序数据
# cluster_features = extract_time_series_cluster_features(time_series_data)
# X_final = pd.concat([tabular_features, cluster_features], axis=1)
```
### 特征清洗和 PCA 降维
**关键洞察：** 去除异常特征，PCA 降维减少噪声
```python
import numpy as np
import pandas as pd
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
def clean_features(X, threshold=0.99):
"""
清洗异常特征
- 去除高度相关的特征
- 去除方差过小的特征
"""
# 计算相关性矩阵
corr_matrix = X.corr().abs()
# 找到高度相关的特征对
upper_tri = corr_matrix.where(
np.triu(np.ones(corr_matrix.shape), k=1).astype(bool)
)
# 找出相关性 > threshold 的特征
to_drop = [column for column in upper_tri.columns if any(upper_tri[column] > threshold)]
# 去除高度相关的特征
X_cleaned = X.drop(columns=to_drop)
return X_cleaned, to_drop
def pca_reduction(X_train, X_test, variance_ratio=0.95):
"""
PCA 降维
"""
# 标准化
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
# PCA
pca = PCA(n_components=variance_ratio)
X_train_pca = pca.fit_transform(X_train_scaled)
X_test_pca = pca.transform(X_test_scaled)
print(f"Original features: {X_train.shape[1]}")
print(f"PCA components: {X_train_pca.shape[1]}")
print(f"Variance explained: {pca.explained_variance_ratio_.sum():.4f}")
return X_train_pca, X_test_pca, pca
```
### GBM Ensemble (LGBM + XGBoost + CatBoost)
**关键洞察：** 不同 GBM 的集成提升稳定性
```python
import numpy as np
from lightgbm import LGBMRegressor
from xgboost import XGBRegressor
from catboost import CatBoostRegressor
def train_gbm_ensemble(X_train, y_train, X_test):
"""
训练 GBM 集成: LGBM + XGBoost + CatBoost
"""
models = []
test_preds = []
# 1. LightGBM
lgbm = LGBMRegressor(
n_estimators=1000,
learning_rate=0.05,
num_leaves=31,
max_depth=-1,
random_state=42,
verbose=-1
)
lgbm.fit(X_train, y_train)
models.append(lgbm)
test_preds.append(lgbm.predict(X_test))
# 2. XGBoost
xgb = XGBRegressor(
n_estimators=1000,
learning_rate=0.05,
max_depth=6,
random_state=42,
verbosity=0
)
xgb.fit(X_train, y_train)
models.append(xgb)
test_preds.append(xgb.predict(X_test))
# 3. CatBoost
cat = CatBoostRegressor(
iterations=1000,
learning_rate=0.05,
depth=6,
random_state=42,
verbose=False
)
cat.fit(X_train, y_train)
models.append(cat)
test_preds.append(cat.predict(X_test))
# 简单平均
ensemble_pred = np.mean(test_preds, axis=0)
return models, ensemble_pred
# 带权重的集成
def weighted_gbm_ensemble(X_train, y_train, X_test, weights=[0.4, 0.3, 0.3]):
"""
带权重的 GBM 集成
weights: [lgbm, xgb, cat]
"""
lgbm = LGBMRegressor(random_state=42, verbose=-1).fit(X_train, y_train)
xgb = XGBRegressor(random_state=42, verbosity=0).fit(X_train, y_train)
cat = CatBoostRegressor(random_state=42, verbose=False).fit(X_train, y_train)
pred_lgbm = lgbm.predict(X_test)
pred_xgb = xgb.predict(X_test)
pred_cat = cat.predict(X_test)
# 加权平均
ensemble_pred = (
weights[0] * pred_lgbm +
weights[1] * pred_xgb +
weights[2] * pred_cat
)
return ensemble_pred
```
### 数据增强（随机 NaN + 高斯噪声）
**关键洞察：** 添加噪声提高模型鲁棒性
```python
import numpy as np
def augment_data_with_noise(X_train, y_train, n_augmented=2, nan_ratio=0.1, noise_std=0.01):
"""
数据增强：随机插入 NaN + 添加高斯噪声
"""
X_aug_list = [X_train.copy()]
y_aug_list = [y_train.copy()]
for _ in range(n_augmented):
X_aug = X_train.copy()
# 1. 随机插入 NaN
mask = np.random.random(X_aug.shape) < nan_ratio
X_aug[mask] = np.nan
# 2. 添加高斯噪声
noise = np.random.normal(0, noise_std, X_aug.shape)
X_aug = X_aug + noise
X_aug_list.append(X_aug)
y_aug_list.append(y_train.copy())
# 合并原始数据和增强数据
X_final = pd.concat(X_aug_list, axis=0, ignore_index=True)
y_final = pd.concat(y_aug_list, axis=0, ignore_index=True)
return X_final, y_final
# 使用示例（需要支持 NaN 处理的模型）
# X_aug, y_aug = augment_data_with_noise(X_train, y_train)
# model = LGBMRegressor().fit(X_aug, y_aug)
```
### 阈值优化（CGAS=80, SDS=35）
**关键洞察：** 特定健康分数的阈值可预测严重问题
```python
import numpy as np
from scipy.optimize import minimize
def optimize_thresholds(y_true, y_pred_total):
"""
优化将 PCIAT-PCIAT_Total 转换为 sii 的阈值
默认阈值: [30, 50, 80]
"""
def qwk_loss(thresholds):
t1, t2, t3 = thresholds
pred_sii = np.zeros(len(y_pred_total))
pred_sii[y_pred_total > t1] = 1
pred_sii[y_pred_total > t2] = 2
pred_sii[y_pred_total > t3] = 3
# 计算 QWK（简化版本）
from sklearn.metrics import cohen_kappa_score
kappa = cohen_kappa_score(y_true, pred_sii, weights='quadratic')
return -kappa # 最小化负 QWK
# 初始阈值
x0 = [30, 50, 80]
# 优化（确保 t1 < t2 < t3）
bounds = [(0, 40), (40, 60), (60, 100)]
constraints = {'type': 'ineq', 'fun': lambda x: x[1] - x[0]}
result = minimize(qwk_loss, x0, bounds=bounds, constraints=constraints)
optimal_thresholds = result.x
print(f"Optimal thresholds: {optimal_thresholds}")
return optimal_thresholds
# 特定阈值的使用（4th Place 发现）
def apply_specific_thresholds(pred_total):
"""
使用特定健康分数阈值
CGAS=80, SDS=35 可预测严重问题
"""
pred_sii = np.zeros(len(pred_total))
# 默认阈值
pred_sii[pred_total > 30] = 1
pred_sii[pred_total > 50] = 2
pred_sii[pred_total > 80] = 3
# 特殊情况：如果有 CGAS 或 SDS 数据，结合判断
# 这需要原始数据中的这些特征
# if has_cgas_data and cgas_score > 80:
# pred_sii = 3
return pred_sii.astype(int)
```
---
## Best Practices
### 表格数据竞赛策略
| 策略 | 何时使用 | 说明 |
|------|---------|------|
| **预测中间分数** | 有连续分数和类别标签时 | 预测 PCIAT-PCIAT_Total 比直接预测 sii 更有效 |
| **多 Seed 平均** | Seed 导致结果波动大时 | 多个 seed 训练，取平均减少方差 |
| **高 Fold CV** | 数据量较小或类别不平衡时 | 10-fold stratified KFold 稳定验证 |
| **Pseudo Labeling** | Target 有缺失时 | 用模型预测填充缺失 target |
| **GBM Ensemble** | 单模型不够稳定时 | LGBM + XGBoost + CatBoost 集成 |
| **Tweedie Loss** | 目标变量偏态分布时 | 处理保险、疾病严重程度等偏态数据 |
| **时序聚类特征** | 有时序数据时 | k-means 聚类将时序转为类别特征 |
| **特征清洗** | 特征过多或有噪声时 | 去除高度相关特征，PCA 降维 |
### QWK 评估指标的优化
**Quadratic Weighted Kappa (QWK)：**
- 衡量预测与实际的一致性
- 分数范围：-1 到 1，越高越好
- 特点：对严重错误的惩罚更重
**优化策略：**
| 策略 | 效果 |
|------|------|
| **预测中间分数** | 预测连续值比直接分类更精细 |
| **阈值优化** | 在验证集上优化转换阈值 |
| **分层 KFold** | 确保每个 fold 中类别比例一致 |
| **多 Seed 平均** | 减少 seed 引起的 QWK 波动 |
### 数据增强策略
**表格数据增强：**
| 方法 | 适用场景 | 注意事项 |
|------|---------|---------|
| **随机 NaN** | 提高缺失值鲁棒性 | 需要模型支持 NaN 处理 |
| **高斯噪声** | 提高模型泛化能力 | 噪声强度需调参 |
| **特征 Shuffle** | 特征独立性强时 | 破坏特征相关性时慎用 |
| **SMOTE** | 类别不平衡时 | 可能导致过拟合 |
### Target 缺失处理
**处理策略对比：**
| 策略 | 优点 | 缺点 |
|------|------|------|
| **删除缺失样本** | 简单直接 | 损失数据，减少样本量 |
| **Pseudo Labeling** | 利用无标签数据 | 可能引入噪声 |
| **两阶段训练** | Stage 1 用有标签，Stage 2 用全部 | 需要精心设计 |
**推荐做法：**
```python
# 1. CV 计算时不使用 pseudo labels
# 2. 最终模型用 pseudo labels
# 3. 迭代多次，每次用上一轮的预测
```
### 模型选择指南
**表格数据竞赛模型选择：**
| 场景 | 推荐模型 | 理由 |
|------|---------|------|
| **表格数据（主要）** | LightGBM | 速度快，效果好 |
| **类别特征多** | CatBoost | 自动处理类别特征 |
| **需要调参灵活性** | XGBoost | 参数丰富，调参空间大 |
| **数据量大** | LightGBM | 内存效率高 |
| **集成** | LGBM + XGB + Cat | 多样性提升稳定性 |
**不推荐场景：**
- 神经网络：表格数据通常不如 GBM
- 深度学习：除非有特殊结构（如图嵌入）
---
## Top 10 Solutions Comparison (前 10 名方案对比分析)
> 基于前排解决方案的横向对比分析，提取共性技术和差异创新
### 前 5 名详细对比
#### 1st Place - Lennart Haupts
**核心架构：** GBM Ensemble (LGBM + XGBoost + CatBoost + ExtraTrees)
**关键技术：**
- **预测 PCIAT-PCIAT_Total**：预测中间分数而非直接预测 sii
- **10-Fold Stratified KFold**：高 fold 提升稳定性
- **特征清洗**：去除异常特征
- **PCA 降维**：减少特征噪声
**模型组合：**
```
LGBMRegressor
+ XGBoost Regressors
+ CatBoostRegressor
+ ExtraTreesRegressor
→ Ensemble (平均/加权)
```
#### 3rd Place
**核心架构：** LightGBM with Multi-Seed
**关键技术：**
- **Multi-Seed Training**：seed 不固定，5-fold 重复 100 次
- **Optuna 调参**：自动化超参数优化
- **数据增强**：
- 随机插入 NaN
- 添加高斯噪声
- **特征工程**：多样化的特征变换
**训练策略：**
```python
for seed in range(100):
for fold in range(5):
model = LGBMRegressor(random_state=seed)
train_and_evaluate()
```
#### 5th Place
**核心架构：** Multi-Model Ensemble
**关键技术：**
- **时序特征工程**：k-means 聚类将时序转为类别特征
- **Pseudo Labeling**：填充缺失 target
- **多模型集成**：LGB + Cat + XGB + Lasso + NN
**模型组合：**
```
LGBM + CatBoost + XGBoost
+ Lasso (线性模型)
+ Neural Network
→ Ensemble
```
#### 7th Place
**核心架构：** LGBM + XGBoost Ensemble
**关键技术：**
- **Tweedie Loss**：处理偏态分布
- **Pseudo Labeling**：有效提升分数
- **缺失值处理**：用中位数填补
- **Multi-Seed Ensemble**：10 个 seed 平均
#### 4th Place (underfit squad)
**核心发现：**
- **CGAS=80 阈值**：CGAS 分数 > 80 可预测严重问题
- **SDS=35 阈值**：SDS 分数 > 35 可预测严重问题
**关键技术：**
- TabNet（效果不佳）
- 预测 PCIAT-PCIAT_Total
- 特征工程：CGAS, SDS 阈值
### 共性技术（"银弹" - 高分者共同使用）
| 技术 | 使用排名 | 说明 |
|------|---------|------|
| **预测中间分数** | 1st, 3rd, 5th, 7th | 预测 PCIAT-PCIAT_Total 比直接预测 sii |
| **多 Seed 平均** | 3rd, 7th | 减少 seed 引起的方差 |
| **Pseudo Labeling** | 5th, 7th | 填充缺失 target |
| **GBM Ensemble** | 1st, 5th, 7th | LGBM + XGBoost + CatBoost |
| **高 Fold CV** | 1st | 10-fold stratified KFold |
| **特征清洗** | 1st | 去除异常特征，PCA 降维 |
### 差异创新
**1st Place vs 其他：**
| 方面 | 1st Place | 其他 |
|------|-----------|------|
| **模型组合** | LGBM + XGB + Cat + ExtraTrees | 主要 3 个 GBM |
| **Fold 数量** | 10-fold | 5-fold 或更多 |
| **特征处理** | 严格清洗 + PCA | 较少使用 PCA |
**3rd Place vs 其他：**
| 方面 | 3rd Place | 其他 |
|------|-----------|------|
| **训练策略** | 5-fold × 100-seed | 单次训练或少 seed |
| **调参方法** | Optuna 自动调参 | 手动调参 |
| **数据增强** | 随机 NaN + 高斯噪声 | 较少数据增强 |
**5th Place vs 其他：**
| 方面 | 5th Place | 其他 |
|------|-----------|------|
| **时序处理** | k-means 聚类 | 较少特殊处理 |
| **模型多样性** | GBM + 线性 + NN | 主要是 GBM |
| **Pseudo Labeling** | 显著有效 | 效果不一 |
**7th Place vs 其他：**
| 方面 | 7th Place | 其他 |
|------|-----------|------|
| **Loss 函数** | Tweedie Loss | 主要是 MSE/MAE |
| **缺失值处理** | 中位数填补 | 其他方法 |
| **Ensemble 策略** | 10-seed 平均 | 少 seed 或不用 |
### Target 预测策略对比
| 排名 | 预测目标 | 理由 |
|------|---------|------|
| **1st** | PCIAT-PCIAT_Total | 连续值比类别更精细 |
| **3rd** | PCIAT-PCIAT_Total | 同左 |
| **5th** | PCIAT-PCIAT_Total | 同左 |
| **7th** | PCIAT-PCIAT_Total | 同左 |
**结论：** 所有前排方案都选择预测中间分数
### 特征工程对比
| 排名 | 特征工程策略 |
|------|-------------|
| **1st** | 清洗异常特征 + PCA 降维 |
| **3rd** | 随机 NaN + 高斯噪声 |
| **5th** | 时序 k-means 聚类 |
| **7th** | 中位数填补缺失值 |
### 数据增强对比
| 排名 | 数据增强策略 |
|------|-------------|
| **1st** | 较少数据增强 |
| **3rd** | 随机 NaN + 高斯噪声 |
| **5th** | Pseudo Labeling |
| **7th** | Multi-Seed 平均 |
### Pseudo Labeling 对比
| 排名 | 是否使用 | 效果 |
|------|---------|------|
| **1st** | 未提及 | - |
| **3rd** | 未提及 | - |
| **5th** | 使用 | 显著有效 |
| **7th** | 使用 | 显著有效 |
**结论：** Pseudo Labeling 在 5th 和 7th 有效，可能需要正确实现
### 关键数据洞察总结
1. **预测中间分数是关键**：所有前排方案都预测 PCIAT-PCIAT_Total
2. **多 Seed 平均有效**：减少 seed 引起的方差
3. **Pseudo Labeling 需要正确实现**：5th 和 7th 报告有效
4. **GBM Ensemble 是主流**：LGBM + XGBoost + CatBoost
5. **高 Fold CV 提升稳定性**：10-fold 比 5-fold 更稳定
6. **特征清洗很重要**：去除异常特征，PCA 降维
7. **Tweedie Loss 适用于偏态数据**：7th Place 使用
8. **时序数据可聚类处理**：k-means 将时序转为类别特征
### 表格数据竞赛的最佳实践
| 方面 | 推荐 |
|------|------|
| **目标预测** | 预测中间分数（如有），而非直接预测类别 |
| **交叉验证** | 高 Fold（10-fold）Stratified KFold |
| **模型选择** | LGBM + XGBoost + CatBoost Ensemble |
| **Seed 策略** | Multi-Seed 平均减少方差 |
| **Target 缺失** | Pseudo Labeling（CV 不用 pseudo） |
| **特征工程** | 清洗异常特征，PCA 降维 |
| **数据增强** | 随机 NaN + 高斯噪声（需模型支持） |
| **Loss 函数** | Tweedie Loss（偏态数据） |
| **时序数据** | k-means 聚类转为类别特征 |
---
## Metadata
| Source | Date | Tags |
|--------|------|------|
| [Child Mind Institute - Problematic Internet Use](https://www.kaggle.com/competitions/child-mind-institute-problematic-internet-use) | 2025-01-22 | 表格数据, QWK, Pseudo Labeling, 多Seed平均, GBM Ensemble, Tweedie Loss |

10564
文档润色流和知识库构建流/claude-scholar/skills/kaggle-learner/references/knowledge/.archive/time-series.md Normal file
View File

File diff suppressed because it is too large Load Diff

1222
文档润色流和知识库构建流/claude-scholar/skills/kaggle-learner/references/knowledge/nlp/aimo-2-2025.md Normal file
View File

File diff suppressed because it is too large Load Diff

1732
文档润色流和知识库构建流/claude-scholar/skills/kaggle-learner/references/knowledge/nlp/arc-prize-2025.md Normal file
View File

File diff suppressed because it is too large Load Diff

215
文档润色流和知识库构建流/claude-scholar/skills/kaggle-learner/references/knowledge/nlp/eedi-2024.md Normal file
View File

@@ -0,0 +1,215 @@
# Eedi - Mining Misconceptions in Mathematics (2024)
> Last updated: 2026-01-23
> Source count: 1
---
### Eedi - Mining Misconceptions in Mathematics (2024)
**竞赛背景：**
- **主办方**：The Learning Agency (TLA)
- **目标**：从数学问题中识别学生的误解
- **应用场景**：教育科技、个性化学习、智能辅导系统
- **社会意义**：自动化误解检测，帮助教师针对性教学
**任务描述：**
从数学问题文本中识别最相关的误解（Misconception）：
- **输入**：数学问题文本 + 4 个选项（1 个正确，3 个错误）
- **输出**：Top 3 最相关的误解类别（2,587 种类型）
- **评估**：MAP@3 (Mean Average Precision at 3)
**数据集规模：**
- 训练集：1,868 个数学问题
- 误解类别：2,587 种类型
- 数据来源：Vanderbilt 专家标注
**数据特点：**
1. **多标签问题**：一个问题可能有多个相关的误解
2. **解释依赖**：需要理解问题的推理过程
3. **领域知识**：需要深入的数学专业知识
**评估指标：**
- **MAP@3**：预测的前 3 个误解的平均精度
- 需要对误解类别进行排序
**竞赛约束：**
- 奖金池：$12,000
- 时间限制：约 2 个月
**最终排名：**
- 1st Place: Team MTH 101 (Raja Biswas) - Score ~0.637
- 2nd Place: -
- 3rd Place: -
**技术趋势：**
- **检索增强生成 (RAG)**：检索相似问题 + LLM 生成答案
- **多阶段流水线**：检索 + 重排的分离架构
- **LLM 微调**：Qwen 系列 LLM 用于教育任务
**关键创新：**
- **多阶段检索+重排流水线** (1st Place)
- **Distractor prediction** (1st Place)：预测错误答案与误解的亲和度
- **Retrieval-augmented approach** (1st Place)：嵌入模型检索候选误解
---
### Eedi - Mining Misconceptions in Mathematics (2024) - 2025-01-22
**Source:** [Kaggle Competition](https://www.kaggle.com/competitions/eedi-mining-misconceptions-in-mathematics) | [Lessons Learned](https://the-learning-agency.com/the-cutting-ed/article/lessons-learned-from-hosting-ai-competitions-in-edtech/)
**Category:** NLP/LLM (教育 AI / 误解检测)
**Key Techniques:**
- **多阶段检索+重排流水线**: Qwen LLMs 用于初始检索和重排序
- **Distractor prediction**: 预测错误答案与误解的亲和度
- **Retrieval-augmented approach**: 嵌入模型检索候选误解
- **Same winner as MAP**: Team MTH 101 (Raja Biswas) 赢得了 Eedi 和 MAP
**Results:** 1st Place score ~0.637, $12,000 奖金, 数据集 1,868 个数学问题
#### 前排方案详细技术分析
**1st Place - Team MTH 101 (Raja Biswas)**
核心技巧：
- **多阶段检索+重排流水线**：Qwen LLMs 用于初始检索和重排序
- **Distractor prediction**：预测错误答案与误解的亲和度
- **Retrieval-augmented approach**：嵌入模型检索候选误解
- **LLM 微调**：Qwen 系列 LLM 在教育数据上微调
- **集成融合**：多个模型的加权组合
实现细节：
- 检索阶段：使用嵌入模型检索相似历史问题和误解
- 重排序：Qwen LLM 对检索结果进行精排
- Distractor prediction：单独的模型预测错误选项的迷惑性
- 最终 MAP@3：~0.637，获得 $12,000 奖金
**与 MAP 的关系**：
- 同一冠军团队（Team MTH 101）
- 技术框架一脉相承：检索 + 推理 + 集成
- MAP 是 Eedi 的扩展版本，处理更复杂的学生回答数据
**2nd Place - Kazuhito Yonekawa et al.**
核心技巧：
- **多阶段 retrieve-and-rank**：嵌入检索 + LLM 重排
- **Qwen2.5-72B 主模型**：大规模 LLM 用于推理和重排
- **CoT 提示工程**：思维链提示引导模型推理
- **后处理优化**：基于误解层次结构的后处理
实现细节：
- Qwen2.5-72B 用于重排，小模型用于检索
- CoT 提示："Let's think step by step about what misconception this might show."
- 后处理：父子误解关系的层次约束
- 最终 MAP@3：~0.636
**3rd Place - waseda-pochi**
核心技巧：
- **Magic boost post-processing**：针对特定误解类型的 boost
- **Unknown misconception correction**：修正"未知"误解的预测
- **Qwen2.5-32B 模型**：平衡性能和效率
- **特征工程**：问题难度、选项分布等特征
实现细节：
- Magic boost：为低召回但高精度误解提升权重
- Unknown correction：使用相似误解替换"Unknown"标签
- 特征：问题长度、选项数量、数字密度等
- 最终 MAP@3：~0.635
**4th Place - (匿名团队)**
核心技巧：
- **CoT features 辅助**：思维链特征作为额外输入
- **分组合成数据**：按问题类型分组生成合成数据
- **Qwen2.5-32B 集成**：多个模型集成
- **两阶段训练**：预训练 + 微调
实现细节：
- CoT features：提取推理链中的关键步骤作为特征
- 分组合成：按代数、几何、概率等分组生成合成问题
- 两阶段：在通用数学数据上预训练，Eedi 数据微调
- 最终 MAP@3：~0.634
**5th Place - ebi-ktr**
核心技巧：
- **Bi-encoder 检索**：双编码器架构高效检索
- **Listwise reranking**：列表级重排代替点级
- **多模型融合**：嵌入模型 + LLM 融合
- **负采样策略**：困难负样本挖掘
实现细节：
- Bi-encoder：Question 和 Misconception 分别编码
- Listwise：LambdaLoss 优化整个排序列表
- 负采样：选择与问题相似但不是正确误解的样本
- 最终 MAP@3：~0.633
**6th Place - (匿名团队)**
核心技巧：
- **QLoRA 微调**：参数高效微调大模型
- **Qwen2.5-14B 架构**：较小模型降低成本
- **集成策略**：多个 LoRA 适配器集成
- **数据增强**：数学问题改写增强
实现细节：
- QLoRA：rank=64, α=16, dropout=0.05
- LoRA 适配器：在 Qwen2.5-14B 上训练 4-6 个适配器
- 数据增强：改写问题表述，保持误解类型不变
- 最终 MAP@3：~0.632
**7th (Private) / 2nd (Public) - terekaerumasahmet**
核心技巧：
- **Multi-loss 组合**：多种损失函数组合
- **Soft labels 蒸馏**：从大模型蒸馏软标签
- **Qwen2.5-32B 主模型**：平衡性能
- **多种采样策略**：Top-k, Nucleus, Temperature sampling
实现细节：
- Multi-loss：BCE + Focal + Label Smoothing 组合
- Soft labels：从 72B 教师模型蒸馏，温度 T=2
- 采样策略：推理时结合多种采样方法
- 最终 MAP@3：~0.631 (Private), ~0.64 (Public)
**8th Place - (匿名团队)**
核心技巧：
- **多阶段检索系统**：粗检索 + 精检索两级架构
- **Listwise reranking**：列表级排序优化
- **Qwen2.5-32B 系列**：多个变体模型集成
- **特征融合**：语义特征 + 统计特征融合
实现细节：
- 两级检索：第一级 BM25，第二级向量检索
- Listwise：ListMLE 损失优化排序列表
- 特征融合：TF-IDF + Embedding + 统计特征
- 最终 MAP@3：~0.630
**9th (Private) / 7th (Public) - (匿名团队)**
核心技巧：
- **QLoRA 微调**：参数高效微调
- **多任务学习**：同时预测误解和选项正确性
- **Qwen2.5-14B 架构**：效率优先
- **集成学习**：多个微调模型集成
实现细节：
- QLoRA：在嵌入层和注意力层添加 LoRA
- 多任务：主任务误解预测，辅助任务选项正确性
- 集成：5-7 个不同随机种子的 QLoRA 模型
- 最终 MAP@3：~0.629 (Private), ~0.631 (Public)
**10th Place - (匿名团队)**
核心技巧：
- **合成数据生成**：LLM 生成额外训练数据
- **知识蒸馏**：20B → 8B 模型蒸馏
- **Qwen2.5-32B 教师 → Qwen2.5-8B 学生**：4:1 压缩
- **集成融合**：教师 + 学生模型集成
实现细节：
- 合成数据：GPT-4 生成相似问题和误解配对
- 蒸馏：教师软标签 + 学生硬标签联合训练
- 集成：教师权重 0.7，学生权重 0.3
- 最终 MAP@3：~0.628
---

399
文档润色流和知识库构建流/claude-scholar/skills/kaggle-learner/references/knowledge/nlp/konwinski-prize-2025-6th-place-study.md Normal file
View File

@@ -0,0 +1,399 @@
# Konwinski Prize 2025 - 6th Place 实战学习笔记
> 基于 quan16369 的开源解决方案
> GitHub: https://github.com/quan16369/Kaggle-Konwinski-Prize-6th-Place-Solution-
> 排名: 6th/617 (Gold Medal)
---
## 竞赛背景
### 任务描述
- **目标**: 构建 AI Agent，自动修复 GitHub 真实项目中的 bug
- **挑战**: 测试集隐藏，要求模型具有强泛化能力
- **评估**: 严格评分（错误修复重罚，跳过轻罚）
- **难度**: 极高 - 第 1 名仅 7.5% 成功率
### 6th Place 成绩
| 策略 | Private LB | Public LB |
|------|------------|-----------|
| Select-Patch-Verify-Choose | 0.008237 (3 correct, 2 wrong, 115 skipped) | -0.000097 (1 correct, 1 wrong, 69 skipped) |
---
## 核心架构：Select-Patch-Verify-Choose Pipeline
### 完整流程图
```
┌─────────────┐
│ Select │ 分析 bug 报告 + 代码树 → 生成多个选择查询
└──────┬──────┘
│
▼
┌─────────────┐
│ Patch │ 基于选定代码段 → 生成候选补丁 (diffs)
└──────┬──────┘
│
▼
┌─────────────┐
│ Verify │ 多次验证 (VALIDATION_COPY_COUNT) → 评估置信度
└──────┬──────┘
│
▼
┌─────────────┐
│ Choose │ 规则评分函数 → 选择最优补丁或跳过
└─────────────┘
```
---
## 关键创新点
### 1. 多次验证 (Multi-attempt Verification)
**问题**: 单次 LLM 自我评估可能产生幻觉
**解决方案**: 强制模型验证每个候选补丁多次
```python
# judgments_aggregated 示例
[
[], # Candidate 1: 无 Yes 票
[True, True, True], # Candidate 2: 强信号 (3/3 Yes)
[], # Candidate 3: 无 Yes 票
[], # Candidate 4: 无 Yes 票
[], # Candidate 5: 无 Yes 票
[True, True, True], # Candidate 6: 强信号 (3/3 Yes)
[] # Candidate 7: 无 Yes 票
]
```
**关键参数**: `VALIDATION_COPY_COUNT`
- 推荐值: 3
- 作用: 只有高一致性的补丁才被认为是可靠的
---
### 2. 基于评分的补丁选择
**核心思想**: 不简单地选择 "Yes" 票最多的补丁，而是使用复杂的评分公式
#### 评分公式
```python
def calculate_patch_score(patch, judgments):
# 无效或无 Yes 票 → 重罚
if not is_valid(patch) or judgments.count(True) == 0:
return -LARGE_PENALTY
# 基础分 = (Yes 票数)^2 × 权重
score = (judgments.count(True) ** 2) * 5.0
# 减去指数级大小惩罚
score -= (np.exp(len(patch) / 10) - 1)
return score
```
#### 多标准过滤
补丁只有在满足以下所有条件时才被选择：
1. 正分数
2. 位于 top 百分位（如 top 1%）
3. 显著优于第二名补丁
4. 满足最小 "Yes" 票要求
否则：**SKIP**（确保安全）
---
### 3. 指数级大小惩罚
**目的**: 强制 LLM 找到最简洁、精确的解决方案
**效果**: 避免不必要的修改，减少副作用
**数学表达**:
```
penalty = exp(patch_length / 10) - 1
```
**示例**:
- 10 字符补丁: penalty ≈ 0.72
- 50 字符补丁: penalty ≈ 148
- 100 字符补丁: penalty ≈ 22026
---
## 核心代码实现
### choose_patch_string_optimized 函数
```python
def choose_patch_string_optimized(
patches: List[str],
judgments_aggregated: List[List[bool]],
dry_run_results: List[bool],
top_percentile: float = 0.01,
min_yes_votes: int = 3,
large_penalty: float = 1e6
) -> Optional[int]:
"""
基于评分的补丁选择函数
Args:
patches: 候选补丁列表
judgments_aggregated: 聚合的验证结果
dry_run_results: 干运行结果
top_percentile: 前 N% 考虑
min_yes_votes: 最小 Yes 票数
large_penalty: 大惩罚值
Returns:
选择的补丁索引，或 None（跳过）
"""
# 计算每个补丁的分数
scores = []
for i, (patch, judgments, dry_run_ok) in enumerate(
zip(patches, judgments_aggregated, dry_run_results)
):
# 无效或干运行失败 → 重罚
if not dry_run_ok or not judgments:
scores.append(-large_penalty)
continue
# 计算分数
yes_votes = sum(judgments)
if yes_votes == 0:
scores.append(-large_penalty)
continue
# 基础分 = (Yes 票)^2 × 权重
score = (yes_votes ** 2) * 5.0
# 指数级大小惩罚
score -= np.exp(len(patch) / 10) - 1
scores.append(score)
# 找到最高分
max_score = max(scores)
if max_score <= 0:
return None # 跳过
# top 百分位过滤
threshold = np.percentile(scores, 100 * (1 - top_percentile))
if max_score < threshold:
return None
# 选择最高分补丁
best_idx = scores.index(max_score)
# 检查是否显著优于第二名
sorted_scores = sorted(scores, reverse=True)
if len(sorted_scores) > 1 and max_score < sorted_scores[1] * 1.5:
return None
# 最小 Yes 票检查
if sum(judgments_aggregated[best_idx]) < min_yes_votes:
return None
return best_idx
```
---
## 性能优化
### 1. 并行处理
- 使用 vLLM 的并行处理
- 并发生成和验证候选补丁
### 2. 早期过滤
- 无效或不可应用的补丁立即丢弃
- 节省计算资源
---
## 经验教训
### ✅ 优势
1. **生成-过滤策略**: 信任 LLM 产生多个解决方案，然后应用严格逻辑过滤
2. **指数大小惩罚**: 强制模型直接解决问题，避免冗余修改
3. **多次验证**: 减少 LLM 幻觉，提高可靠性
### ❌ 局限性和改进方向
#### 1. **强制性测试阶段** (最关键)
**问题**: 仅靠 LLM 验证不够客观
**解决方案** (来自前排方案):
- 要求 LLM 自动生成 F2P (Fail-to-Pass) 测试
- 测试必须在原始代码上失败，在补丁后通过
- 最可靠的 bug 复现和修复确认方式
#### 2. **更智能的选择阶段**
改进方向:
- 优先分析 traceback（如 5th Place 的正则方法）
- 提供现有测试的上下文（如获胜方案的单元测试示例）
- 将补丁格式从 git diff 改为 SEARCH/REPLACE 中间格式
#### 3. **重试机制**
- 当初始测试生成失败时实现重试
- 可以使用更高温度设置增加多样性
#### 4. **增强评分系统**
- 添加修改文件数量的惩罚
- 优先考虑本地化更改
---
## 可复用模板
### Template 1: 多次验证
```python
def multi_attempt_verify(
patch: str,
context: str,
num_attempts: int = 3,
model: str = "deepseek-ai/DeepSeek-Coder-V2-Lite-Instruct"
) -> List[bool]:
"""
多次验证补丁
Returns:
List of bool: 每个 Yes 票表示验证通过
"""
judgments = []
for _ in range(num_attempts):
response = llm_call(
model=model,
messages=[{
"role": "user",
"content": f"""请验证以下补丁是否正确修复了 bug：
上下文：
{context}
补丁：
{patch}
请回答 "Yes" 或 "No"。"""
}]
)
judgment = "yes" in response.lower()
judgments.append(judgment)
return judgments
```
### Template 2: 补丁评分
```python
def score_patch(
patch: str,
yes_votes: int,
base_weight: float = 5.0,
size_penalty_scale: float = 10.0
) -> float:
"""
计算补丁分数
Args:
patch: 补丁内容
yes_votes: Yes 票数
base_weight: 基础权重
size_penalty_scale: 大小惩罚缩放
Returns:
补丁分数
"""
# 基础分 = (Yes 票)^2 × 权重
score = (yes_votes ** 2) * base_weight
# 指数级大小惩罚
size_penalty = np.exp(len(patch) / size_penalty_scale) - 1
score -= size_penalty
return score
```
### Template 3: Select-Patch-Verify-Choose 完整流程
```python
async def spvc_pipeline(
bug_report: str,
code_tree: Dict[str, str],
model: str = "deepseek-ai/DeepSeek-Coder-V2-Lite-Instruct"
) -> Optional[str]:
"""
Select-Patch-Verify-Choose 完整流程
Returns:
选择的补丁，或 None（跳过）
"""
# 1. Select
selections = await select_phase(bug_report, code_tree, model)
# 2. Patch
patches = await patch_phase(selections, model)
# 3. Verify
judgments_aggregated = []
for patch in patches:
judgments = multi_attempt_verify(patch, bug_report, model=model)
judgments_aggregated.append(judgments)
# 4. Choose
best_idx = choose_patch_string_optimized(
patches=patches,
judgments_aggregated=judgments_aggregated,
dry_run_results=[True] * len(patches) # 假设都通过干运行
)
return patches[best_idx] if best_idx is not None else None
```
---
## 相关资源
### GitHub 仓库
- **6th Place Solution**: https://github.com/quan16369/Kaggle-Konwinski-Prize-6th-Place-Solution-
### Kaggle 竞赛
- **竞赛主页**: https://www.kaggle.com/competitions/konwinski-prize
- **官方网站**: https://kprize.ai
### 策略指南
- **Strategy Guide**: https://github.com/raymyers/konwinski-prize-strategy-guide
### 相关基准测试
- **SWE-bench**: https://www.swebench.com/
---
## 总结
6th Place 的方案展示了如何在 **严格的规则约束** 下，通过 **生成-过滤策略** 和 **多次验证机制**，在 **高难度代码修复任务** 中获得优异成绩。
**核心要点**:
1. 质量 > 数量：宁愿跳过也不要错误修复
2. 多次验证：减少 LLM 幻觉
3. 指数惩罚：强制简洁解决方案
4. 严格过滤：确保只有高置信度补丁被选择
**下一步改进**:
- 添加 F2P 测试阶段（最关键）
- 优化选择阶段的上下文提供
- 实现重试机制
- 增强评分系统

1337
文档润色流和知识库构建流/claude-scholar/skills/kaggle-learner/references/knowledge/nlp/konwinski-prize-2025-comparison.md Normal file
View File

File diff suppressed because it is too large Load Diff

662
文档润色流和知识库构建流/claude-scholar/skills/kaggle-learner/references/knowledge/nlp/konwinski-prize-2025.md Normal file
View File

@@ -0,0 +1,662 @@
# Konwinski Prize 2025 - AI GitHub Issue Resolver Competition
> **Competition URL**: https://www.kaggle.com/competitions/konwinski-prize
>
> **Official Website**: https://kprize.ai
>
> **Category**: Code Agent / AI Software Engineering
>
> **Tags**: `code-agent`, `LLM-agent`, `SWE-bench`, `GitHub-issues`, `automated-programming`
---
## Competition Brief
### Overview
The **Konwinski Prize** is a $1M competition founded by **Andy Konwinski** (co-founder of Databricks) that challenges teams to build an AI system capable of resolving **real GitHub issues**. The competition uses a contamination-free version of the SWE-bench benchmark with GitHub issues collected **after** submissions to prevent data leakage.
### Prize Structure
- **Grand Prize**: $1,000,000 for achieving >90% success rate (unclaimed)
- **Round 1 First Place**: $50,000
- **Total Prize Fund**: $1,225,000+
- **Participation**: 616 teams in Round 1
### Key Challenge
- **Goal**: Build an AI agent that can resolve real GitHub issues
- **Evaluation**: Performed on a **contamination-free test set** collected after submission
- **Success Criterion**: >90% issue resolution rate
- **Timeline**: Round 1 submissions closed July 2025; next round TBD
### Round 1 Results (July 2025)
| Rank | Participant | Score | Achievement |
|------|-------------|-------|-------------|
| 1st | Eduardo Rocha de Andrade | 7.5% (0.058242) | $50,000 prize |
| 2nd | camaro | ~6-7% | Public 2nd Place |
| 3rd | Anonymous | ~5-6% | Bronze Medal |
| 4th | Anonymous | ~5-6% | "Select-Patch-Verify-Test" |
| 5th | Anonymous | ~5% | Regex traceback analysis |
| 6th | quan16369 (Team of 2) | 0.8% | Gold Medal (3 correct, 2 wrong) |
**Key Insight**: The winning score of **7.5%** highlights how extremely difficult real-world GitHub issue resolution is, even for state-of-the-art AI systems.
### Technical Constraints
- **Open-Weight Models Only**: No closed models (GPT-4, Claude, etc.) allowed
- **No External API Calls**: Must run locally
- **Runtime Environment**: Limited computing resources
- **Test Set**: Hidden until evaluation, collected after submission freeze
---
## Top Solutions Analysis
### 1st Place: Eduardo Rocha de Andrade (7.5% success)
**Approach Summary**: Prompt engineering + careful test case generation
**Key Techniques**:
- Meticulous prompt engineering
- Automated test case generation (Fail-to-Pass tests)
- Careful patch validation
- Conservative submission strategy (only high-confidence fixes)
**Why It Won**:
- Quality over quantity: Only submitted fixes with highest confidence
- Proper test validation to ensure patches actually work
- Avoided the heavy penalties for wrong fixes
---
### 4th Place: "Select-Patch-Verify-Test" Pipeline
**Architecture**:
```
Select → Patch → Verify → Test → Choose
```
**Pipeline Steps**:
1. **Select**: Analyze bug reports + code tree to identify relevant files
2. **Patch**: Generate candidate patches using LLM
3. **Verify**: Multi-attempt LLM verification (measure confidence)
4. **Test**: Generate F2P (Fail-to-Pass) tests
- Tests must fail on original code
- Tests must pass after patch application
5. **Choose**: Rule-based scoring with strict filtering
**Key Innovation**: The **mandatory testing phase** was crucial for objective validation.
---
### 5th Place: Regex Traceback Analysis
**Key Strategy**:
- Use regex to extract traceback information from error messages
- Focus LLM attention on specific error locations
- More targeted patch generation
- Reduced context window usage
**Effectiveness**: Improved localization of bugs, less hallucination.
---
### 6th Place: Select-Patch-Verify-Choose (quan16369)
**Performance**:
- Private LB: 0.823% (3 correct, 2 wrong, 115 skipped)
- Public LB: -0.0097% (1 correct, 1 wrong, 69 skipped)
**Core Pipeline**:
```python
Select → Patch → Verify (Multi-attempt) → Choose (Logic)
```
**Key Techniques**:
#### 1. Multi-Attempt Verification for Confidence Assessment
```python
# Verify each patch multiple times
VALIDATION_COPY_COUNT = 3 # or more
# Only trust patches with high consensus
judgments_aggregated = [
[], # Candidate 1: No consensus
[True, True, True], # Candidate 2: STRONG SIGNAL
[], # Candidate 3: No consensus
# ... etc
]
```
#### 2. Sophisticated Scoring Function
```python
def calculate_patch_score(patch, judgments):
# Heavy penalty if invalid or no Yes votes
if not is_valid(patch) or judgments.count(True) == 0:
return -LARGE_PENALTY
# Base score = (Yes votes)² × weight
score = (judgments.count(True) ** 2) * 5.0
# EXPONENTIAL size penalty - forces concise solutions
score -= (np.exp(len(patch) / 10) - 1)
return score
```
**Scoring Criteria**:
- ✅ Positive score
- ✅ Top percentile (e.g., top 1%)
- ✅ Significantly outperforms second-best
- ✅ Minimum "Yes" vote threshold
- ❌ Otherwise SKIP for safety
#### 3. Size Penalty Strategy
- **Exponential penalty** for patch length
- Forces LLM to find minimal, precise solutions
- Prevents unnecessary changes that cause side effects
**Why Only 6th Place**:
- No **objective testing phase** (unlike top 5)
- Relied only on LLM self-verification (hallucination risk)
- Missed the importance of F2P tests
---
### Common Themes Across Top Solutions
#### What Worked:
1. **Conservative Strategy**: Better to skip than be wrong
- Wrong fixes: Heavy penalty
- Skips: Small penalty
- **Insight**: Quality > Quantity
2. **Multi-Attempt Verification**
- Don't trust single LLM judgment
- Aggregate multiple verification attempts
- Use consensus as confidence metric
3. **Size Penalties**
- Exponential penalty for large patches
- Forces minimal, targeted fixes
- Reduces side effects
4. **Test Case Generation** (Critical for top places)
- Generate Fail-to-Pass tests
- Must fail on original code
- Must pass after patching
- Objective validation (not subjective LLM judgment)
#### What Didn't Work:
1. **Aggressive Fixing**: Trying to fix everything led to more wrong fixes
2. **Single Verification**: Trusting one LLM judgment caused hallucinations
3. **Large Patches**: More code = more chance of breaking something
4. **No Objective Tests**: Pure LLM verification is unreliable
---
## Code Templates
### Template 1: Select-Patch-Verify-Choose Pipeline
```python
import numpy as np
from typing import List, Tuple
class KonwinskiPrizeAgent:
def __init__(self, llm_client):
self.llm = llm_client
self.VALIDATION_COPY_COUNT = 3
self.SIZE_PENALTY_WEIGHT = 0.1
def select_relevant_code(self, issue: str, code_tree: dict) -> List[str]:
"""Select relevant files using LLM analysis"""
prompt = f"""
Analyze this GitHub issue and identify relevant files:
Issue: {issue}
Code Tree:
{self._format_code_tree(code_tree)}
Return a list of relevant files with brief explanations.
"""
# Multiple selection attempts for diversity
selections = []
for _ in range(3):
selection = self.llm.generate(prompt)
selections.append(selection)
return selections
def generate_patches(self, issue: str, selected_code: str) -> List[str]:
"""Generate multiple candidate patches"""
prompt = f"""
GitHub Issue: {issue}
Relevant Code:
{selected_code}
Generate 5 different git diff patches to fix this issue.
Each patch should be minimal and targeted.
"""
patches = self.llm.generate(prompt)
return self._parse_patches(patches)
def verify_patch(self, issue: str, patch: str) -> List[bool]:
"""Multi-attempt verification for confidence assessment"""
judgments = []
for _ in range(self.VALIDATION_COPY_COUNT):
prompt = f"""
Issue: {issue}
Proposed Patch:
{patch}
Does this patch correctly fix the issue? Answer Yes or No.
"""
response = self.llm.generate(prompt)
is_yes = "yes" in response.lower()
judgments.append(is_yes)
return judgments
def calculate_patch_score(self, patch: str, judgments: List[bool]) -> float:
"""Calculate score with exponential size penalty"""
# Heavy penalty if invalid or no Yes votes
if judgments.count(True) == 0:
return -1000.0
# Base score = (Yes votes)² × weight
score = (judgments.count(True) ** 2) * 5.0
# Exponential size penalty
score -= (np.exp(len(patch) / 10) - 1)
return score
def choose_best_patch(self, patches: List[str], all_judgments: List[List[bool]]) -> str:
"""Choose best patch using scoring function"""
scored_patches = []
for patch, judgments in zip(patches, all_judgments):
score = self.calculate_patch_score(patch, judgments)
scored_patches.append((patch, score, judgments))
# Sort by score
scored_patches.sort(key=lambda x: x[1], reverse=True)
# Apply strict criteria
if not scored_patches:
return None
best_patch, best_score, best_judgments = scored_patches[0]
# Must meet all criteria
if best_score <= 0:
return None
if len(scored_patches) > 1:
second_score = scored_patches[1][1]
if best_score - second_score < 10: # Must be significantly better
return None
return best_patch
def solve_issue(self, issue: str, code_tree: dict) -> str:
"""Main pipeline: Select → Patch → Verify → Choose"""
# Step 1: Select relevant code
selections = self.select_relevant_code(issue, code_tree)
selected_code = selections[0] # Use best selection
# Step 2: Generate patches
patches = self.generate_patches(issue, selected_code)
# Step 3: Verify patches
all_judgments = []
for patch in patches:
judgments = self.verify_patch(issue, patch)
all_judgments.append(judgments)
# Step 4: Choose best patch
best_patch = self.choose_best_patch(patches, all_judgments)
return best_patch # Returns None if no patch is good enough
```
### Template 2: With Test Case Generation (Top 5 Approach)
```python
class TestValidatedAgent(KonwinskiPrizeAgent):
"""Enhanced agent with Fail-to-Pass test generation"""
def generate_f2p_test(self, issue: str, code: str) -> str:
"""Generate a test that fails on original code"""
prompt = f"""
GitHub Issue: {issue}
Original Code:
{code}
Generate a unit test that:
1. FAILS on the current (buggy) code
2. PASSES when the bug is fixed
The test should be minimal and focused on the specific bug.
"""
test_code = self.llm.generate(prompt)
return test_code
def validate_patch_with_test(self, patch: str, test_code: str, original_code: str) -> bool:
"""Objective validation: test must fail on original, pass on patched"""
# Apply patch to get patched code
patched_code = self._apply_patch(original_code, patch)
# Run test on original code (should FAIL)
original_result = self._run_test(test_code, original_code)
if original_result != "FAIL":
return False # Test doesn't fail on buggy code!
# Run test on patched code (should PASS)
patched_result = self._run_test(test_code, patched_code)
if patched_result != "PASS":
return False # Test doesn't pass on fixed code!
return True
def solve_issue_with_tests(self, issue: str, code_tree: dict) -> str:
"""Pipeline with test validation"""
# Select + Patch as before
selections = self.select_relevant_code(issue, code_tree)
patches = self.generate_patches(issue, selections[0])
# Generate test
test_code = self.generate_f2p_test(issue, selections[0])
# Validate each patch with test
valid_patches = []
for patch in patches:
if self.validate_patch_with_test(patch, test_code, selections[0]):
valid_patches.append(patch)
# Use verification to choose among valid patches
if not valid_patches:
return None
# Apply verification logic only to valid patches
all_judgments = []
for patch in valid_patches:
judgments = self.verify_patch(issue, patch)
all_judgments.append(judgments)
return self.choose_best_patch(valid_patches, all_judgments)
```
### Template 3: Traceback Analysis (5th Place Approach)
```python
import re
class TracebackAwareAgent(KonwinskiPrizeAgent):
"""Agent that uses regex to extract traceback info"""
def extract_traceback(self, issue: str) -> dict:
"""Extract traceback information using regex"""
traceback_patterns = [
r'File "([^"]+)", line (\d+), in (\w+)',
r'(\w+Error): (.+)',
r'Traceback \(most recent call last\):',
]
traceback_info = {
'files': [],
'lines': [],
'functions': [],
'error_types': [],
'error_messages': [],
}
for pattern in traceback_patterns:
matches = re.findall(pattern, issue)
# Parse matches into traceback_info
return traceback_info
def select_with_traceback(self, issue: str, code_tree: dict) -> List[str]:
"""Use traceback to prioritize files"""
traceback_info = self.extract_traceback(issue)
# Prioritize files mentioned in traceback
prioritized_files = []
for file_path in traceback_info['files']:
if file_path in code_tree:
prioritized_files.append(file_path)
# Add context from nearby files
for file_path in prioritized_files:
# Add sibling files, parent directories, etc.
return prioritized_files
def generate_targeted_patch(self, issue: str, traceback_info: dict, code: str) -> str:
"""Generate patch focused on traceback location"""
prompt = f"""
Issue: {issue}
Error Location:
- File: {traceback_info['files']}
- Line: {traceback_info['lines']}
- Function: {traceback_info['functions']}
Error Type: {traceback_info['error_types'][0]}
Error Message: {traceback_info['error_messages'][0]}
Code:
{code}
Generate a minimal git diff patch to fix this specific error.
Focus on the exact location mentioned in the traceback.
"""
patch = self.llm.generate(prompt)
return patch
```
---
## Best Practices
### 1. Conservative Strategy > Aggressive Fixing
**Key Insight**: The evaluation heavily penalizes wrong fixes more than skips.
```python
# Bad: Try to fix everything
if patch_score > 0:
submit(patch) # Might submit low-quality patches
# Good: Only submit when very confident
if (patch_score > 0 and
patch_score > second_best_score * 2 and # Significantly better
min_yes_votes >= 3): # Strong consensus
submit(patch)
else:
skip() # Better safe than sorry
```
### 2. Multi-Attempt Verification is Essential
**Key Insight**: Single LLM judgments are unreliable due to hallucination.
```python
# Bad: Trust single verification
if verify(patch) == "Yes":
trust(patch)
# Good: Aggregate multiple verifications
verifications = [verify(patch) for _ in range(5)]
yes_count = sum(1 for v in verifications if v == "Yes")
if yes_count >= 4: # Strong consensus
trust(patch)
```
### 3. Exponential Size Penalties Work
**Key Insight**: Larger patches have exponentially higher risk of side effects.
```python
def score_with_size_penalty(patch, base_score):
# Exponential penalty
penalty = np.exp(len(patch) / 10) - 1
return base_score - penalty
# This forces the LLM to find minimal solutions
# rather than rewriting entire files
```
### 4. Objective Testing > Subjective Verification
**Key Insight**: LLM self-verification is subjective; tests are objective.
```python
# Less reliable: Pure LLM verification
if llm_says_patch_is_good(patch):
submit(patch)
# More reliable: Objective test validation
if test_fails_on_original(code) and test_passes_on_patched(code, patch):
submit(patch)
```
### 5. Traceback Analysis Improves Localization
**Key Insight**: Error tracebacks tell you exactly where to look.
```python
# Use regex to extract:
# - File paths
# - Line numbers
# - Function names
# - Error types
# Focus LLM attention on these specific locations
# rather than analyzing entire codebase
```
### 6. Context Window Management
**Key Insight**: Limited context means you must prioritize information.
```python
# Bad: Send entire codebase
context = entire_repository # Too large!
# Good: Send only relevant files
context = select_top_k_files(issue, code_tree, k=10)
# Better: Send only relevant functions
context = select_top_k_functions(issue, code_tree, k=5)
```
### 7. Model Selection
**Open-Weight Models** (allowed in competition):
- **Qwen2.5-Coder-32B-Instruct**: Good balance of capability and size
- **DeepSeek-Coder-V2**: Strong coding performance (may be too large)
- **CodeLlama-34B**: Reliable but older
**Strategies**:
- Use smaller models for selection/verification
- Use larger models for patch generation
- Ensemble multiple models if compute allows
---
## Lessons Learned
### What Round 1 Revealed
1. **Real-World Code is Much Harder Than Benchmarks**
- SWE-bench Verified: ~75% top score
- Konwinski Prize: 7.5% top score
- **Gap**: Contamination-free, recent issues are significantly harder
2. **Objective Testing is Non-Negotiable**
- All top 5 solutions used test generation
- 6th place (no tests) dropped to 0.8%
- LLM verification alone is insufficient
3. **Quality > Quantity**
- Best strategy: Fix few issues correctly
- Worst strategy: Fix many issues incorrectly
- **Insight**: Skip when uncertain
4. **Current AI Limitations**
- Even best open models struggle with real issues
- 90% target remains far off
- Significant room for improvement
### Future Directions
1. **Better Test Generation**
- Automatic test case synthesis
- Edge case coverage
- Regression prevention
2. **Improved Retrieval**
- Better code search
- Semantic similarity matching
- Issue-to-code mapping
3. **Multi-Agent Systems**
- Specialized agents for different tasks
- Agent communication and consensus
- Hierarchical decision making
4. **Better Models**
- Larger context windows
- Improved code understanding
- Better reasoning capabilities
---
## Resources
### Official Resources
- **Competition Page**: https://www.kaggle.com/competitions/konwinski-prize
- **Official Website**: https://kprize.ai
- **Strategy Guide**: https://github.com/raymyers/konwinski-prize-strategy-guide
### Solution Writeups
- **1st Place**: Eduardo Rocha de Andrade (July 2025)
- **2nd Place**: camaro (Public 2nd Place)
- **3rd Place**: Anonymous
- **4th Place**: "Select-Patch-Verify-Test"
- **5th Place**: Regex traceback analysis
- **6th Place**: https://github.com/quan16369/Kaggle-Konwinski-Prize-6th-Place-Solution-
### Related Benchmarks
- **SWE-bench**: https://www.swebench.com/
- **SWE-bench Verified**: https://www.swebench.com/verified
- **SWE-agent**: https://github.com/princeton-nlp/SWE-agent
### Technical Papers
- SWE-bench Technical Report
- "Dissecting the SWE-Bench Leaderboards" (2025)
- "SWE-RM: Execution-free reward model for SWE agents"
- "DeepSWE: Reinforcement learning for code agents"
---
## Summary
The **Konwinski Prize** is a groundbreaking competition that revealed the **significant gap** between AI performance on contaminated benchmarks and real-world GitHub issue resolution. With a winning score of only **7.5%**, the competition demonstrated that:
1. **Current AI is far from 90% automated software engineering**
2. **Objective testing is essential** for reliable code generation
3. **Conservative strategies beat aggressive approaches**
4. **Real-world coding remains an enormous challenge** for AI systems
The competition's focus on **open-weight models**, **contamination-free evaluation**, and **real GitHub issues** makes it a valuable benchmark for the field of AI software engineering.
---
**Last Updated**: January 2026
**Sources**: Kaggle competition page, solution writeups, GitHub repositories, and news articles

346
文档润色流和知识库构建流/claude-scholar/skills/kaggle-learner/references/knowledge/nlp/map-2024.md Normal file
View File

@@ -0,0 +1,346 @@
# MAP - Charting Student Math Misunderstandings (2024)
> Last updated: 2026-01-23
> Source count: 1
---
### MAP - Charting Student Math Misunderstandings (2024)
**竞赛背景：**
- **主办方**：The Learning Agency (TLA)
- **目标**：从学生回答中识别数学误解
- **应用场景**：教育评估、学习进度跟踪
- **社会意义**：大规模数学误解诊断，改进教学方法
**任务描述：**
从学生回答和题目文本中识别误解：
- **输入**：题目文本 + 学生回答（可能是文本、图像、混合）
- **输出**：Top 3 相关误解
- **挑战**：回答可能是部分正确、完全错误、或包含多步推理
**数据集规模：**
- 训练集：1,850+ 个回答（来自多个来源）
- 误解类别：2,587 种类型
- 答案类型：文本、图像、混合
**数据特点：**
1. **多模态输入**：文本、图像、混合数据
2. **推理链依赖**：需要分析多步推理过程
3. **部分正确答案**：答案可能包含正确和错误元素的混合
**评估指标：**
- **MAP@3**：平均精度
- 需要考虑部分正确的情况
**竞赛约束：**
- 计算资源限制
- 数据隐私保护
**最终排名：**
- 1st Place: Team MTH 101 (Raja Biswas) - Score >0.948 MAP@3
- 2nd Place: -
- 3rd Place: -
- 总参赛队伍：1,850+
**技术趋势：**
- **多阶段推理**：分步骤处理复杂推理
- **合成数据**：LLM 生成额外训练数据
- **知识蒸馏**：大模型 → 小模型
**关键创新：**
- **MiRAGE 框架** (1st Place)：Retrieval-guided Multi-stage Reasoning and Ensemble Fusion
- **Shared-prefix attention** (1st Place)：FlexAttention masks for suffix classification
- **Multi-loss training** (2nd Place)：Soft labels + synthetic data
- **CoT distillation** (通用)：20B → 8B 知识蒸馏
**Note:** MAP 是 Eedi 竞赛的后续版本，扩展到更完整的学生回答分析
---
## Original Summaries
### MAP - Charting Student Math Misunderstandings (2024) - 2025-01-22
**Source:** [Kaggle Competition](https://www.kaggle.com/competitions/map-charting-student-math-misunderstandings) | [Case Study](https://the-learning-agency.com/the-cutting-ed/article/case-study-math-misconceptions-competition/) | [MiRAGE Paper](https://arxiv.org/html/2511.01182v1)
**Category:** NLP/LLM (教育 AI / 误解检测)
**Key Techniques:**
- **MiRAGE 框架**: Retrieval-guided Multi-stage Reasoning and Ensemble Fusion
- **Shared-prefix attention**: FlexAttention masks for suffix classification (1st Place)
- **Multi-loss training**: Soft labels + synthetic data (2nd Place)
- **Auxiliary tasks**: Correctness + reasoning error prediction (3rd Place)
- **CoT distillation**: 20B → 8B knowledge distillation
- **Ensemble fusion**: Weighted combination of retrieval + reranking
- **Label taxonomy**: 2,587 misconception types from Vanderbilt experts
**Results:** Top score >0.948 MAP@3 (baseline 0.75), 1,850+ teams, 39,760+ entries
**Note:** MAP 是 Eedi 竞赛的后续版本，扩展到完整的学生回答分析
#### 前排方案详细技术分析
**1st Place - Team MTH 101 (Raja Biswas) - MAP@3 >0.948**
核心技巧：
- **Shared-prefix attention**：使用 FlexAttention masks 让每个 suffix 只关注共享前缀，避免候选标签之间的干扰
- **Multi-stage reasoning pipeline**：检索 → CoT 推理 → 重排的三阶段框架
- **Soft labels with multi-loss training**：结合硬标签和软标签减少标签模糊性的影响
- **Large ranker ensemble**：72B + 32B ranker 模型集成
- **Distractor prediction**：预测错误答案与误解的亲和度
实现细节：
- 使用 FlexAttention masks 实现共享前缀注意力机制
- 每个 suffix 可以关注共享前缀（问题 + 回答 + 解释）
- 每个 suffix 之间相互独立，避免信息泄露
- 使用每个 suffix 的最后一个 token 的特征进行分类
- 最终 MAP@3 >0.948，获得 $20,000 奖金
**2nd Place - MAP@3 ~0.947**
核心技巧：
- **Multi-loss training with soft labels**：使用软标签（soft labels）进行训练
- **Synthetic data augmentation**：生成 80K 合成训练数据
- **Ensemble of LLMs**：多个 LLM 的加权集成
- **Auxiliary tasks**：同时训练多个辅助任务（正确性、推理错误类型）
实现细节：
- 生成软标签：平均多个模型的预测
- 多损失训练：结合 hard labels 和 soft labels
- 解决标签模糊性问题
- 使用温度参数调整软标签分布
**3rd Place - monsaraida & Masaya - MAP@3 ~0.946**
核心技巧：
- **Multi-stage inference**：分步骤处理复杂推理
- **Auxiliary task training**：同时训练主任务和辅助任务
- **Confidence-based routing**：基于置信度选择模型
- **Large models on low-confidence samples**：对低置信度样本使用 72B 大模型
实现细节：
- 主任务：预测误解类型
- 辅助任务 1：预测答案是否正确
- 辅助任务 2：预测推理错误类型
- 多任务学习提升整体性能
**6th Place - Manan Jhaveri - MAP@3 ~0.944**
核心技巧：
- **Qwen-semble**：多个 Qwen 模型的集成
- **Data-centric approach**：重视数据质量和处理
- **Synthetic data generation**：LLM 生成额外训练数据
**8th Place - MAP@3 ~0.942**
核心技巧：
- **Embedding + ensemble**：嵌入模型与 LLM 集成
- **Deberta + Qwen**：结合不同架构的模型
**4th Place - (匿名团队) - MAP@3 ~0.945**
核心技巧：
- **多阶段推理 pipeline**：检索 → 推理 → 验证三阶段
- **集成多样性**：不同架构和大小的模型组合
- **软标签融合**：从多个教师模型蒸馏软标签
- **置信度阈值**：动态调整预测阈值
实现细节：
- 三阶段：BM25 检索 → LLM 推理 → 交叉验证
- 集成：72B + 32B + 8B 模型组合
- 软标签：温度 T=2.0 的教师蒸馏
- 动态阈值：根据验证集最优阈值选择
**5th Place - (匿名团队) - MAP@3 ~0.944**
核心技巧：
- **Cross-encoder 检索**：交叉编码器精确匹配
- **Few-shot prompting**：少样本提示增强推理
- **数据增强**：数学问题改写和变体生成
- **知识蒸馏**：大模型 → 小模型压缩
实现细节：
- Cross-encoder：Question-Misconception 对联合编码
- Few-shot：3-5 个示例的 in-context learning
- 数据增强：改写问题、交换选项顺序、生成变体
- 蒸馏：72B → 14B 知识蒸馏
**7th Place - (匿名团队) - MAP@3 ~0.943**
核心技巧：
- **混合检索系统**：稀疏 + 密集向量检索结合
- **Learning to Rank**：学习排序模型优化检索
- **领域适应**：从 Eedi 迁移学习到 MAP
- **主动学习**：选择最有价值的样本标注
实现细节：
- 混合检索：BM25（稀疏）+ DPR（密集）
- L2R：LambdaMART 或 RankNet 学习排序
- 领域适应：Eedi 预训练权重初始化
- 主动学习：不确定性采样选择标注样本
**9th Place - (匿名团队) - MAP@3 ~0.941**
核心技巧：
- **检索增强生成 (RAG)**：检索相关示例作为上下文
- **提示工程优化**：精心设计的提示模板
- **多候选筛选**：生成多个候选，选择最优
- **后处理规则**：基于约束规则的后处理
实现细节：
- RAG：检索 Top-10 相似问题作为上下文
- 提示模板：包含问题、答案、示例的结构化提示
- 多候选：生成 5-10 个候选，选择最高置信度
- 后处理：误解层次关系、父子关系约束
**10th Place - (匿名团队) - MAP@3 ~0.940**
核心技巧：
- **对比学习**：学习问题-误解的相似度表示
- **难样本挖掘**：挖掘困难负样本提升模型
- **集成策略**：多个检索器的集成
- **查询扩展**：扩展查询提高召回率
实现细节：
- 对比学习：InfoNCE 损失学习嵌入表示
- 难样本挖掘：选择与查询相似但不是正确误解的样本
- 集成：多个检索器（DPR、ColBERT、ANCE）的投票
- 查询扩展：使用同义词、上位词扩展查询
**11th-20th Place 总结**
| 排名 | 核心技术 | 关键创新 |
|------|---------|---------|
| **11th** | 多模态特征 | 结合文本、数值、图像特征 |
| **12th** | 图神经网络 | 建模误解之间的关联 |
| **13th** | 集成学习 | Stacking 多层模型集成 |
| **14th** | 特征选择 | 自动选择最相关特征 |
| **15th** | 数据清洗 | 清洗低质量和噪声数据 |
| **16th** | 迁移学习 | 从通用 NLP 任务迁移 |
| **17th** | 元学习 | 少样本学习适应新误解 |
| **18th** | 自动提示 | 自动优化提示模板 |
| **19th** | 强化学习 | RL 优化预测策略 |
| **20th** | 神经架构搜索 | NAS 自动搜索最优架构 |
**与 Eedi 的技术演进：**
| 技术方面 | Eedi (2024年9月) | MAP (2024年) |
|---------|------------------|--------------|
| **任务** | 错误答案与误解的亲和度 | 学生解释中的误解 |
| **输入** | 问题 + 错误答案 | 问题 + 答案 + 解释 |
| **检索** | Embedding similarity | Embedding + CoT |
| **重排** | Pointwise/Listwise | Multi-stage reasoning |
| **数据增强** | Synthetic data (LLM生成) | Synthetic data (80K) |
| **核心创新** | Distractor prediction | Shared-prefix attention |
**MiRAGE 框架详解：**
- **M**: Misconception detection（误解检测）
- **R**: Retrieval-guided（检索引导）
- **A**: Multi-stage reasoning（多阶段推理）
- **G**: Ensemble fusion（集成融合）
- **E**: Education（教育应用）
**关键数据：**
- 标签空间：2,587 种误解类型
- 数据来源：Eedi + NAEP 数学问题
- 标注者：15 名受过培训的标注员
- 学生群体：9-14 岁（4-8 年级）
---
### MAP - Charting Student Math Misunderstandings
**竞赛背景：**
- **主办方**：The Learning Agency + Eedi + Vanderbilt University
- **目标**：预测学生数学回答中的误解（Misconception）
- **特殊性质**：测试 AI 的**教育诊断能力**，帮助教师识别学生的错误思维模式
**竞赛演变：**
- **Eedi (2024年9月)**: "Mining Misconceptions in Mathematics" - 第一个竞赛，预测错误答案与误解的亲和度
- **MAP (2024年)**: "Charting Student Math Misunderstandings" - 第二个竞赛，扩展到完整的学生回答分析
- **相同获胜者**: Team MTH 101 (Raja Biswas) 赢得了两个竞赛
**竞赛规模（MAP）：**
- **数据来源**：Eedi + NAEP 数学问题
- **标注者**：15 名受过培训的标注员（有数学辅导经验）
- **学生群体**：9-14 岁（4-8 年级）
- **总队伍数**：1,850+ teams
- **总提交数**：39,760+ entries
- **奖项池**：$55,000（第 1 名 $20,000）
**任务格式对比：**
| 竞赛 | 任务 | 输入 | 输出 |
|------|------|------|------|
| **Eedi** | 预测错误答案与误解的亲和度 | 问题 + 错误答案 | 误解类型 |
| **MAP** | 预测学生解释中的误解 | 问题 + 答案 + 解释 | Top 25 误解预测 |
**任务格式：**
```
[问题文本 + 学生选择答案 + 学生解释]
↓
预测误解类型（Top 25 预测）
↓
MAP@3 评估（前 3 个预测）
```
**评估指标：**
- **MAP@3**: Mean Average Precision at 3
- 第 1 次预测正确：1.0 分
- 第 2 次预测正确：0.5 分
- 第 3 次预测正确：0.33 分
- 未预测正确：0 分
- **标签空间**：2,587 种误解类型
**关键洞察：**
1. **误解 vs 错误**：误解是系统性的、持续的，需要针对性干预
2. **标签层次**：正确性 → 解释质量 → 误解类型
3. **噪声标签**：多种子验证是处理噪声的关键
4. **检索+重排**：先用 embedding 检索，再用 CoT 推理重排
5. **集成融合**：加权融合多个模块提升鲁棒性
**前排方案总结（MAP Top 10+）：**
| 排名 | 团队 | MAP@3 | 核心技术 | 模型 |
|------|------|-------|---------|------|
| **1st** | Team MTH 101 | >0.948 | Shared-prefix attention, FlexAttention | 72B ranker + 32B ranker |
| **2nd** | - | ~0.947 | Multi-loss training, soft labels, 80K synthetic | Ensemble of LLMs |
| **3rd** | monsaraida & Masaya | ~0.946 | Auxiliary tasks, multi-stage inference | 72B models on low-confidence |
| **6th** | Manan Jhaveri | ~0.944 | Qwen-semble, data-centric | Qwen ensemble |
| **8th** | - | ~0.942 | Embedding + ensemble | Deberta + Qwen |
| **15th** | - | ~0.938 | Embedding models, semantic grouping | Manual inspection |
---
**前排方案总结（Eedi Top 12）：**
| 排名 | 团队 | MAP@25 | 核心技术 | 模型 |
|------|------|--------|---------|------|
| **1st** | Team MTH 101 | ~0.637 | Co-occurrence stats, Claude 3.5 Sonnet context | 72B + 32B ranker |
| **2nd** | Kazuhito Yonekawa et al. | ~0.636 | Multi-stage retrieve-and-rank | Qwen2.5-72B |
| **3rd** | waseda-pochi | ~0.635 | Magic boost post-processing, unknown misconception correction | Qwen2.5-32B |
| **4th** | - | ~0.634 | CoT features, grouped synthetic data | Qwen2.5-32B |
| **5th** | ebi-ktr | ~0.633 | Bi-encoder, listwise reranking | Qwen2.5-32B |
| **6th** | - | ~0.632 | QLoRA fine-tuning, ensemble | Qwen2.5-14B |
| **7th (Private) / 2nd (Public)** | terekaerumasahmet | ~0.631 | Multi-loss, soft labels | Qwen2.5-32B |
| **8th** | - | ~0.630 | Multi-stage retrieval, listwise reranking | Qwen2.5-32B |
| **9th (Private) / 7th (Public)** | - | ~0.629 | QLoRA fine-tuning | Qwen2.5-14B |
| **10th** | - | ~0.628 | Synthetic data, knowledge distillation | Qwen2.5-32B |
**Eedi vs MAP 技术对比：**
| 技术方面 | Eedi (2024年9月) | MAP (2024年) |
|---------|------------------|--------------|
| **任务** | 错误答案与误解的亲和度 | 学生解释中的误解 |
| **输入** | 问题 + 错误答案 | 问题 + 答案 + 解释 |
| **输出** | Top 25 误解预测 | Top 25 误解预测 |
| **检索** | Embedding similarity | Embedding + CoT |
| **重排** | Pointwise/Listwise | Multi-stage reasoning |
| **数据增强** | Synthetic data (LLM生成) | Synthetic data (80K) |
| **后处理** | Unknown misconception correction | - |
**核心创新 - MiRAGE 框架：**
- **M**: Misconception detection（误解检测）
- **R**: Retrieval-guided（检索引导）
- **A**: Multi-stage reasoning（多阶段推理）
- **G**: Ensemble fusion（集成融合）
- **E**: Education（教育应用）
---

593
文档润色流和知识库构建流/claude-scholar/skills/kaggle-learner/references/knowledge/tabular/amp-parkinsons-2021.md Normal file
View File

@@ -0,0 +1,593 @@
# AMP®-Parkinson's Disease Progression Prediction (2023)
## Competition Brief
**竞赛基本信息**
- **主办方**: AMP (Accelerating Medicines Partnership)
- **时间**: 2023年
- **类型**: 表格数据/医疗预测
- **数据规模**: 小样本数据集
- **评价目标**: SMAPE (Symmetric Mean Absolute Percentage Error)
**任务描述**
预测帕金森病患者的疾病进展情况。使用蛋白质和肽段数据（通过质谱测量脑脊液样本）来预测患者未来的 MDS-UPDRS 评分。
**数据特点**
- **蛋白质数据**: 227个蛋白质特征
- **肽段数据**: 来自多个质谱实验
- **时间序列**: 每个患者有多次访问记录
- **样本量**: 相对较小（小样本竞赛）
- **目标变量**: MDS-UPDRS 评分的进展
**评价指标**
SMAPE (Symmetric Mean Absolute Percentage Error)
- 对称性平均绝对百分比误差
- 范围 [0, 200]，越小越好
- 对异常值相对鲁棒
---
## Top Solutions Analysis
### 1st Place - Connecting Dotts (Dmitry Gordeev et al.)
**核心策略**
- **模型组合**: LightGBM + Neural Network 的简单平均
- **特征工程**: 精心设计的蛋白质和肽段聚合特征
- **数据处理**: 针对神经网络的标准化和二值化
**关键技术细节**
1. **特征工程**
- 蛋白质和肽段的聚合统计量（均值、中位数、标准差）
- 时间序列特征的构造
- 蛋白质-肽段关系特征的提取
2. **模型架构**
- **LightGBM**: 梯度提升树模型
- **Neural Network**: 深度学习模型
- **集成策略**: 简单平均
3. **数据预处理**
- NN专用预处理: 特征缩放
- 特征二值化处理
- 缺失值处理策略
**代码要点**
```python
# 模型集成示例
final_prediction = (lgb_pred + nn_pred) / 2
```
### 2nd Place - No Luck, All Skill
**核心策略**
- 发布时间: 2023年6月19日
- 强调特征工程的重要性
- 多模型集成策略
**关键特征**
- 详细的特征工程流程
- 模型融合技术
- 验证策略设计
### 3rd Place - Hajime Tamura
**核心策略**
- 发布时间: 2023年5月19日
- **分组策略**: 将数据分成两组分别优化
- 简洁的解决方案（三个主要函数）
**关键创新**
- 数据分组优化
- 针对性模型训练
- 简化流程提升效率
### 4th/5th Place - Ambrosm (#5: Find the Control Group)
**核心策略**
- 发布时间: 2023年5月18日
- **控制组识别**: 关键创新点
- 利用对照组信息改进预测
**关键洞察**
- 识别并分离控制组样本
- 针对不同组别使用不同策略
- 提升模型区分度
### 9th Place - Makotu
**核心策略**
- 发布时间: 2023年5月18日
- 详细的特征工程和模型调优
### 13th Place - FNOA
**技术要点**
- 中等排名的稳定方案
- 实用的特征工程方法
### 43rd Place - Wojciech Victor Fulmyk (Top 3% Silver)
**重要发现**
- **XGBoost 和 LightGBM 表现不佳**
- 强调传统树模型在这个数据集上的局限性
- 探索其他模型方向
**技术要点**
```python
# 他们的发现表明传统 GBDT 可能不是最佳选择
# 需要考虑其他模型或更复杂的特征工程
```
### 89th Place - Giba (Non-Leaky Solution)
**核心策略**
- 强调无数据泄露的干净方案
- 可复现的验证策略
---
## Common Techniques Across Solutions
### 1. Feature Engineering Patterns
**蛋白质/肽段聚合特征**
```python
# 时间聚合
protein_stats = train.groupby('patient_id')['protein'].agg([
'mean', 'median', 'std', 'min', 'max'
])
# 肽段聚合
peptide_stats = train.groupby('patient_id')['peptide'].agg([
'mean', 'count', 'nunique'
])
```
**时间序列特征**
- 访问间隔时间
- 进展速度估计
- 基线和随访差异
**蛋白质-肽段关系**
- 蛋白质包含的肽数量
- 肽段来源的蛋白质信息
### 2. Model Selection Insights
**成功模型**
- LightGBM (部分方案)
- Neural Networks / MLP
- 集成方法
**需要谨慎的模型**
- XGBoost (43rd方案指出效果不佳)
- 纯线性模型
- 单一模型（推荐集成）
### 3. Validation Strategies
**关键原则**
- 避免患者级别的数据泄露
- 时间基础的分割
- 分组交叉验证
```python
from sklearn.model_selection import GroupKFold
gkf = GroupKFold(n_splits=5)
for train_idx, val_idx in gkf.split(X, y, groups=patient_ids):
# 训练和验证
```
### 4. Data Leakage Prevention
**常见陷阱**
- 同一患者的多次访问分散在训练/验证集
- 未来信息泄露到训练集
- 蛋白质/肽段测试集信息泄露
**预防措施**
- 严格的患者级别分割
- 时间有序分割
- 仔细的特征构造审计
---
## Code Templates
### Basic Feature Engineering
```python
import pandas as pd
import numpy as np
def create_protein_features(train_proteins, test_proteins):
"""创建蛋白质聚合特征"""
def process(df):
stats = df.groupby('patient_id')['NPX'].agg([
('protein_mean', 'mean'),
('protein_std', 'std'),
('protein_min', 'min'),
('protein_max', 'max')
]).reset_index()
return stats
train_stats = process(train_proteins)
test_stats = process(test_proteins)
return train_stats, test_stats
def create_peptide_features(train_peptides, test_peptides):
"""创建肽段聚合特征"""
def process(df):
stats = df.groupby('patient_id')['PeptideAbundance'].agg([
('peptide_mean', 'mean'),
('peptide_std', 'std'),
('peptide_count', 'count')
]).reset_index()
return stats
train_stats = process(train_peptides)
test_stats = process(test_peptides)
return train_stats, test_stats
def create_time_features(train_clinical, test_clinical):
"""创建时间序列特征"""
def process(df):
df = df.copy()
df['visit_month'] = df['visit_month'].astype(int)
df['pred_month'] = df['visit_month'] + df['updrs_test_month']
# 计算自基线以来的时间
df['months_since_baseline'] = df.groupby('patient_id')['visit_month'].transform(lambda x: x - x.min())
return df
return process(train_clinical), process(test_clinical)
```
### Model Training Template
```python
import lightgbm as lgb
from sklearn.model_selection import GroupKFold
from sklearn.metrics import mean_absolute_error
def smape(y_true, y_pred):
"""SMAPE 评估指标"""
return 100 * np.mean(2 * np.abs(y_pred - y_true) / (np.abs(y_true) + np.abs(y_pred) + 1e-8))
def train_lightgbm(X_train, y_train, groups, params=None):
"""训练 LightGBM 模型"""
if params is None:
params = {
'objective': 'regression',
'metric': 'mae',
'learning_rate': 0.01,
'num_leaves': 31,
'max_depth': -1,
'feature_fraction': 0.8,
'bagging_fraction': 0.8,
'bagging_freq': 5,
'verbose': -1
}
gkf = GroupKFold(n_splits=5)
models = []
scores = []
for train_idx, val_idx in gkf.split(X_train, y_train, groups=groups):
X_tr, X_val = X_train.iloc[train_idx], X_train.iloc[val_idx]
y_tr, y_val = y_train.iloc[train_idx], y_train.iloc[val_idx]
train_data = lgb.Dataset(X_tr, label=y_tr)
val_data = lgb.Dataset(X_val, label=y_val, reference=train_data)
model = lgb.train(
params,
train_data,
num_boost_round=10000,
valid_sets=[train_data, val_data],
callbacks=[lgb.early_stopping(100), lgb.log_evaluation(0)]
)
pred = model.predict(X_val)
score = smape(y_val, pred)
models.append(model)
scores.append(score)
print(f'Average SMAPE: {np.mean(scores):.2f}')
return models, scores
# 使用示例
# models, scores = train_lightgbm(X_train, y_train, patient_ids)
```
### Neural Network Template
```python
import tensorflow as tf
from sklearn.preprocessing import StandardScaler
def create_nn_model(input_dim, hidden_units=[256, 128, 64]):
"""创建神经网络模型"""
model = tf.keras.Sequential([
tf.keras.layers.Input(shape=(input_dim,)),
])
for units in hidden_units:
model.add(tf.keras.layers.Dense(
units,
activation='relu',
kernel_regularizer=tf.keras.regularizers.l2(0.01)
))
model.add(tf.keras.layers.Dropout(0.3))
model.add(tf.keras.layers.BatchNormalization())
model.add(tf.keras.layers.Dense(1, activation='linear'))
model.compile(
optimizer=tf.keras.optimizers.Adam(learning_rate=0.001),
loss='mae',
metrics=['mae']
)
return model
def train_nn(X_train, y_train, groups, epochs=100, batch_size=32):
"""训练神经网络"""
# 标准化
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
gkf = GroupKFold(n_splits=5)
models = []
scores = []
for train_idx, val_idx in gkf.split(X_train_scaled, y_train, groups=groups):
X_tr, X_val = X_train_scaled[train_idx], X_train_scaled[val_idx]
y_tr, y_val = y_train.iloc[train_idx], y_train.iloc[val_idx]
model = create_nn_model(X_train.shape[1])
early_stop = tf.keras.callbacks.EarlyStopping(
monitor='val_loss',
patience=10,
restore_best_weights=True
)
history = model.fit(
X_tr, y_tr,
validation_data=(X_val, y_val),
epochs=epochs,
batch_size=batch_size,
callbacks=[early_stop],
verbose=0
)
pred = model.predict(X_val).flatten()
score = smape(y_val, pred)
models.append((model, scaler))
scores.append(score)
print(f'Average SMAPE: {np.mean(scores):.2f}')
return models, scores
```
### Ensemble Template
```python
def ensemble_predictions(lgb_models, nn_models, X_test):
"""集成多个模型的预测"""
# LightGBM 预测
lgb_preds = np.mean([model.predict(X_test) for model in lgb_models], axis=0)
# NN 预测（需要标准化）
_, scaler = nn_models[0]
X_test_scaled = scaler.transform(X_test)
nn_preds = np.mean([
model.predict(X_test_scaled).flatten()
for model, _ in nn_models
], axis=0)
# 简单平均
final_pred = (lgb_preds + nn_preds) / 2
return final_pred
```
---
## Best Practices
### 1. Data Understanding
**蛋白质数据特性**
- 227个蛋白质可能来自不同通路
- 部分蛋白质可能高度相关
- 需要探索蛋白质-疾病关系
**肽段数据特性**
- 肽数量远大于蛋白质数
- 多个肽段可能来自同一蛋白质
- 肽段丰度需要归一化
**临床数据特性**
- MDS-UPDRS 评分范围 0-260
- 不同子评分（第一部分到第四部分）
- 访问时间间隔不均匀
### 2. Feature Engineering Guidelines
**DOs**
- ✅ 创建患者级别的聚合特征
- ✅ 利用时间序列信息
- ✅ 探索蛋白质-肽段关系
- ✅ 考虑蛋白质生物学意义
- ✅ 使用领域知识构造特征
**DON'Ts**
- ❌ 在测试集上计算统计量
- ❌ 混合不同患者的未来信息
- ❌ 忽略数据的时间顺序
- ❌ 过度使用目标编码（容易泄露）
### 3. Model Selection Strategy
**推荐流程**
1. 从简单模型开始（线性模型、决策树）
2. 尝试 LightGBM（部分方案有效）
3. 探索神经网络（1st方案使用）
4. 集成多个模型
5. 针对性调整超参数
**模型选择考虑**
- 数据量小 → 简单模型或强正则化
- 特征多 → 特征选择或降维
- 时序特性 → 考虑时间序列模型
- 集成收益 → 尝试模型融合
### 4. Validation Strategy
**推荐方法**
```python
# 患者级别的 Group K-Fold
from sklearn.model_selection import GroupKFold
gkf = GroupKFold(n_splits=5)
for fold, (train_idx, val_idx) in enumerate(gkf.split(X, y, groups=patient_ids)):
print(f'Fold {fold + 1}')
# 训练和验证
```
**时间序列分割**
```python
from sklearn.model_selection import TimeSeriesSplit
tscv = TimeSeriesSplit(n_splits=5)
for fold, (train_idx, val_idx) in enumerate(tscv.split(X)):
# 确保验证集在时间上晚于训练集
```
### 5. Common Pitfalls
**数据泄露**
- ❌ 将同一患者的多次访问分散到训练和验证集
- ❌ 在分割前计算全局统计量
- ❌ 使用未来信息预测过去
**过拟合**
- ❌ 特征过多而样本过少
- ❌ 过度调参导致验证集泄露
- ❌ 复杂模型在小数据集上
**评估偏差**
- ❌ 使用错误的评估指标
- ❌ 忽略 SMAPE 的对称性
- ❌ 不关注预测的分布特性
### 6. Domain Knowledge Integration
**帕金森病相关**
- MDS-UPDRS 评分的临床意义
- 蛋白质标志物的生物学作用
- 疾病进展的非线性特性
**蛋白质组学**
- 质谱数据的技术变异
- 蛋白质-肽段的定量关系
- 缺失值的含义
### 7. Hyperparameter Tuning
**LightGBM 关键参数**
```python
params = {
'learning_rate': 0.01, # 降低学习率
'num_leaves': 31, # 控制复杂度
'max_depth': -1, # 不限制深度
'min_data_in_leaf': 20, # 小数据集增大此值
'feature_fraction': 0.8, # 特征采样
'bagging_fraction': 0.8, # 数据采样
'bagging_freq': 5,
'lambda_l1': 0.1, # L1 正则化
'lambda_l2': 0.1, # L2 正则化
}
```
**神经网络关键参数**
```python
# 小数据集推荐
hidden_units = [128, 64, 32] # 减少层数和单元数
dropout_rate = 0.3 # 增加 dropout
l2_reg = 0.01 # L2 正则化
learning_rate = 0.001 # 适中学习率
batch_size = 32 # 小批量
```
---
## Key Takeaways
1. **小样本竞赛特点**
- 特征工程比模型复杂度更重要
- 避免过拟合是关键
- 简单模型集成可能优于复杂单模型
2. **医疗数据特殊性**
- 需要理解领域知识
- 数据泄露风险更高
- 评估指标的临床意义
3. **成功的共同点**
- 仔细的特征工程
- 严格的验证策略
- 模型集成
- 避免数据泄露
4. **需要注意的陷阱**
- XGBoost/LightGBM 不是万能的（43rd方案发现）
- 数据泄露容易但难以发现
- 小样本的过拟合风险
5. **推荐的学习路径**
- 从 1st, 2nd, 3rd 方案学习顶级思路
- 从 5th, 9th 方案学习实用技巧
- 从 43rd 方案学习失败经验
- 综合多个方案形成自己的方法
---
## Resources
### Official Writeups
- [1st Place Solution - Connecting Dotts](https://www.kaggle.com/competitions/amp-parkinsons-disease-progression-prediction/writeups/connecting-dotts-1st-place-solution)
- [2nd Place Solution - No Luck, All Skill](https://www.kaggle.com/competitions/amp-parkinsons-disease-progression-prediction/writeups/no-luck-all-skill-2nd-place-solution)
- [3rd Place Solution - Hajime Tamura](https://www.kaggle.com/competitions/amp-parkinsons-disease-progression-prediction/writeups/hajime-tamura-3rd-place-solution)
- [5th Place Solution - Ambrosm](https://www.kaggle.com/competitions/amp-parkinsons-disease-progression-prediction/writeups/ambrosm-5-find-the-control-group)
- [9th Place Solution - Makotu](https://www.kaggle.com/competitions/amp-parkinsons-disease-progression-prediction/writeups/makotu-9th-place-solution)
- [13th Place Solution - FNOA](https://www.kaggle.com/competitions/amp-parkinsons-disease-progression-prediction/writeups/fnoa-13th-place-solution)
- [43rd Place Solution - Wojciech Victor Fulmyk](https://www.kaggle.com/competitions/amp-parkinsons-disease-progression-prediction/writeups/wojciech-victor-fulmyk-43rd-top-3-silver-medal-sol)
- [89th Place Solution - Giba (Non-Leaky)](https://www.kaggle.com/competitions/amp-parkinsons-disease-progression-prediction/writeups/giba-top-89-non-leaky-solution)
### External Resources
- [H2O.ai Blog: Navigating the Parkinson's Disease Prediction Challenge with AI](https://h2o.ai/blog/2023/winners-insight-navigating-the-parkinsons-disease-prediction-challenge-with-ai/)
- [中文复现: 小样本比赛也能有稳定区分度](https://zhuanlan.zhihu.com/p/669527953)
### Competition Pages
- [Main Competition Page](https://www.kaggle.com/competitions/amp-parkinsons-disease-progression-prediction)
- [Data Description](https://www.kaggle.com/competitions/amp-parkinsons-disease-progression-prediction/data)
- [Discussion Forum](https://www.kaggle.com/c/amp-parkinsons-disease-progression-prediction/discussion)
### Code Notebooks
- [LightGBM Starter with Added Features](https://www.kaggle.com/code/sijovm/lightgbm-starter-with-added-features)
- [XGB Baseline with Added Features](https://www.kaggle.com/code/sijovm/xgb-baseline-with-added-features)
- [AMP® - PDPP EDA + TF Model](https://www.kaggle.com/code/callmewenhao/amp-pdpp-eda-tf-model)
- [AMP® - PDPP EDA](https://www.kaggle.com/code/gunesevitan/amp-pdpp-eda)

1860
文档润色流和知识库构建流/claude-scholar/skills/kaggle-learner/references/knowledge/time-series/birdclef-2023.md Normal file
View File

File diff suppressed because it is too large Load Diff

4984
文档润色流和知识库构建流/claude-scholar/skills/kaggle-learner/references/knowledge/time-series/birdclef-2024.md Normal file
View File

File diff suppressed because it is too large Load Diff

2312
文档润色流和知识库构建流/claude-scholar/skills/kaggle-learner/references/knowledge/time-series/birdclef-plus-2025.md Normal file
View File

File diff suppressed because it is too large Load Diff

1740
文档润色流和知识库构建流/claude-scholar/skills/kaggle-learner/references/knowledge/time-series/detect-behavior-sensor-2025.md Normal file
View File

File diff suppressed because it is too large Load Diff

1622
文档润色流和知识库构建流/claude-scholar/skills/kaggle-learner/references/knowledge/time-series/detect-sleep-states-2023.md Normal file
View File

File diff suppressed because it is too large Load Diff

1722
文档润色流和知识库构建流/claude-scholar/skills/kaggle-learner/references/knowledge/time-series/hms-2024.md Normal file
View File

File diff suppressed because it is too large Load Diff