Skip to content
Back to search

agentic-kaggle-skill

Kaggle-first end-to-end competition workflow for scored submissions. Use when Codex must run Kaggle or competitive ML workflows through scored submission, including code competitions, validation, metrics, policy-safe public notebook/discussion intel, tabular/text/image modeling, tuning, ensembling/stacking, proactive multi-notebook architectures, producer notebooks that train models and export private Kaggle artifact datasets, downstream consumer notebooks, Kaggle GPU offload, kagglehub access, hidden-test debugging, and public score retrieval.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/franks-intellab--agentic-kaggle-skill/badge.svg)](/listings/franks-intellab--agentic-kaggle-skill)

HTML

<a href="/listings/franks-intellab--agentic-kaggle-skill"><img src="/api/listings/franks-intellab--agentic-kaggle-skill/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Codex

Install as a user-level Codex skill:

作为用户级 Codex skill 安装:

mkdir -p ~/.agents/skills
git clone https://github.com/FrankS-IntelLab/agentic-kaggle-skill.git \
  ~/.agents/skills/agentic-kaggle-skill

Restart Codex if the skill does not appear immediately. Invoke it explicitly with:

如果 skill 没有立即出现,请重启 Codex。可以这样显式调用:

Use $agentic-kaggle-skill to help me start this Kaggle competition.

For repo-scoped development, place or symlink this folder under a repository's `.agents/skills/` directory:

如果只想在某个仓库中启用,可以把该目录放到或软链接到仓库的 `.agents/skills/`:

mkdir -p .agents/skills
ln -s /path/to/agentic-kaggle-skill .agents/skills/agentic-kaggle-skill

Hermes

Install the whole skill folder so references and scripts are available:

安装完整 skill 目录,确保 references 和 scripts 都可用:

mkdir -p ~/.hermes/skills/data-science
git clone https://github.com/FrankS-IntelLab/agentic-kaggle-skill.git \
  ~/.hermes/skills/data-science/agentic-kaggle

Then ask Hermes to use the agentic Kaggle skill for competition work.

然后让 Hermes 使用 agentic Kaggle skill 来处理竞赛任务。

Helper Script Dependencies / 辅助脚本依赖

Most scripts use only the Python standard library. `scripts/make_folds.py` requires pandas and numpy; scikit-learn is recommended for standard splitters.

大部分脚本只依赖 Python 标准库。`scripts/make_folds.py` 需要 pandas 和 numpy;推荐安装 scikit-learn 以使用标准切分器。

python3 -m pip install -r requirements.txt

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 233 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. ---
  2. name: agentic-kaggle-skill
  3. description: Kaggle-first end-to-end competition workflow for scored submissions. Use when Codex must run Kaggle or competitive ML workflows through scored submission, including code competitions, validation, metrics, policy-safe public notebook/discussion intel, tabular/text/image modeling, tuning, ensembling/stacking, proactive multi-notebook architectures, producer notebooks that train models and export private Kaggle artifact datasets, downstream consumer notebooks, Kaggle GPU offload, kagglehub access, hidden-test debugging, and public score retrieval.
  4. ---
  5. # Agentic Kaggle Skill
  6. ## Operating Loop
  7. Treat every competition as a validation problem first and a modeling problem second. The default target platform is Kaggle, so prefer Kaggle-native notebooks/scripts, datasets, model artifacts, competition submissions, and score receipts. For code competitions, assume the final notebook/kernel will be rerun by Kaggle against hidden data unless the competition docs prove otherwise.
  8. 1. Read the competition page, classify the submission mode as classic file submission or code/notebook scoring, then inspect the rules, data-use terms, sharing policy, data dictionary, metric, submission format, train/test construction hints, and leakage warnings.
  9. 2. If live competition intelligence tools are available, inspect top public open notebook solutions and relevant discussion activity before major architecture choices; treat them as clues, not authority.
  10. 3. Identify the task type: binary, multiclass, multilabel, regression, ranking, image, segmentation, text, time series, grouped entities, or a hybrid.
  11. 4. Design folds before feature engineering or modeling. Prefer a fold column saved into the training data so every experiment uses the same comparison surface.
  12. 5. Build the simplest metric-correct baseline and produce out-of-fold (OOF) predictions plus a valid submission.
  13. 6. Proactively plan a stronger architecture once the baseline is trustworthy: diverse model families, feature/embedding producers, augmentation/pseudo-label/distillation stages, calibration/postprocessing, and an ensemble or stacker.
  14. 7. Iterate with validation gates: test one meaningful change at a time when possible, but launch several independent producer notebooks in parallel when they create diverse artifacts that can be compared by OOF score or ensemble diversity.
  15. 8. Offload heavy training, inference, embedding generation, image/text experiments, or memory-risky jobs to Kaggle notebooks/scripts when local compute may OOM or take too long. Before GPU scheduling or availability claims, fetch fresh quota and apply the GPU quota accounting rule below.
  16. 9. For sophisticated architectures, split work into a small Kaggle pipeline: run several independent producer notebooks/scripts first, save each useful producer output as a private Kaggle dataset, then run one consumer notebook/script that attaches those datasets and creates the final OOF/test/submission outputs. When a producer trains a model, its checkpoint, tokenizer/config, fold metadata, OOF/test predictions, and manifest should be exported as a Kaggle dataset; downstream notebooks load the model from `/kaggle/input/...`.
  17. 10. Submit the final submission-producing artifact to Kaggle for scoring and retrieve the resulting submission status/score.
  18. 11. If Kaggle returns a code-competition error or vague scoring failure, enter the debugging loop: retrieve available logs, classify likely failure mode, patch defensively, rerun the final kernel, resubmit, and repeat until scored or concretely blocked.
  19. 12. Track local CV, remote Kaggle run status, Kaggle submission score, public LB, private-risk notes, seed, code version, data version, and artifact paths for every run.
  20. 13. Ensemble only with OOF predictions generated without in-fold leakage.
  21. ## Resource Map
  22. - Read `references/method-map.md` for the neutral workflow map behind the skill.
  23. - Read `references/information-sharing-policy.md` before publishing competition code, notebooks, datasets, models, artifacts, or reports outside the active team or workspace.
  24. - Read `references/competition-intel.md` when a Kaggle competition slug, URL, title, public leaderboard context, open solutions, or discussion activity may inform the approach.
  25. - Read `references/cross-validation-and-metrics.md` when choosing folds, metrics, thresholds, or leakage checks.
  26. - Read `references/tabular-workflow.md` for categorical variables, feature engineering, selection, and hyperparameter tuning.
  27. - Read `references/image-text-workflow.md` for image, segmentation, and NLP competition approaches.
  28. - Read `references/kaggle-code-competition-pipeline.md` when the target is a Kaggle code competition, hidden rerun, final notebook scoring flow, or model artifact handoff between producer and consumer notebooks.
  29. - Read `references/advanced-notebook-architecture.md` when a stronger solution may need multiple model families, staged feature/embedding/model producers, pseudo-labeling, distillation, postprocessing, blending, stacking, or parallel Kaggle GPU notebooks.
  30. - Read `references/kaggle-offload.md` when local runs are heavy, GPU is useful, Kaggle data access is needed, or remote notebook results must be collected.
  31. - Read `references/kaggle-pipeline-datasets.md` when using multiple Kaggle notebooks, intermediate datasets, notebook output sources, or `kagglehub`.
  32. - Read `references/submission-endgame.md` before stopping work; this skill is not done until Kaggle scoring has been attempted and the result has been collected or a concrete blocker is documented.
  33. - Read `references/code-competition-debugging.md` when a Kaggle code competition submission fails, times out, OOMs, produces no score, or reports a vague hidden-run/scoring error.
  34. - Read `references/ensembling-and-reproducibility.md` for project layout, OOF artifacts, stacking, blending, and repeatability.
  35. - Read `references/research/` or `examples/` only when the user asks for historical case studies, Hermes-era patterns, or concrete competition lessons from this repository.
  36. - Run `scripts/scaffold_competition.py` to create a competition workspace.
  37. - Run `scripts/make_folds.py` to add a fold column to a training CSV.
  38. - Run `scripts/prepare_kaggle_kernel.py` to create a Kaggle kernel folder with metadata and retrievable experiment logs.
  39. - Run `scripts/prepare_kaggle_dataset.py` to create metadata and commands for versioned intermediate artifact datasets.
  40. ## Default Kaggle Procedure
  41. Start with the metric and validation:
  42. - Reproduce the competition metric locally, including clipping, transforms, averaging mode, thresholds, and sample weights.
  43. - Check whether the competition allows public code, external data, pretrained weights, generated artifacts, and public repositories before sharing anything outside the team.
  44. - Classify the Kaggle submission path early. If it is a code competition or notebook-scored workflow, design the final consumer notebook as the scoring artifact from the start.
  45. - Use `kaggle-competition-intel` MCP tools when available: `top_open_solutions` for score-ranked plus latest high-vote notebooks, and `competition_discussions` for top-voted plus recently active discussion topics before choosing expensive baselines.
  46. - Choose folds to match the hidden test distribution. Use stratification for classification, binned stratification for regression, group splits for repeated entities, time-aware splits for temporal data, and multilabel-aware splits when label co-occurrence matters.
  47. - Save OOF predictions for every model. OOF files are the currency for error analysis, threshold tuning, blending, and stacking.
  48. - Compare mean fold score and fold variance, not only the best fold.
  49. - Treat a public LB jump that disagrees with CV as a validation question before treating it as a modeling victory.
  50. Then build baselines in this order:
  51. 1. Metric-only or constant baseline to verify scoring and submission format.
  52. 2. Fast classical baseline: LightGBM/CatBoost/XGBoost for tabular, TF-IDF plus linear model for text, pretrained backbone for images.
  53. 3. Strong baseline with stable folds, clean artifacts, and OOF predictions.
  54. 4. Feature/model experiments with run logs and one primary metric.
  55. 5. Ensembling or stacking after several diverse, individually validated models exist.
  56. Do not wait for the user to explicitly ask for sophistication when the competition warrants it. After a stable baseline, propose and execute a stronger staged architecture if public solutions, discussion intel, data modality, metric pressure, or CV plateau suggests that a single notebook/model will underperform. Keep the architecture gated by OOF evidence, artifact manifests, and final Kaggle scoring.
  57. When a run is likely to exceed local RAM/VRAM, require a GPU/TPU, or needs Kaggle-only data mounts, prepare a Kaggle kernel run instead of forcing it locally. The remote run must emit `experiment_log.json`, `metrics.jsonl`, and an artifact manifest so results can be retrieved and interpreted after `kaggle kernels output`.
  58. When the solution has multiple heavy stages, keep the remote graph shallow and inspectable:
  59. - Use fewer than five independent producer notebooks/scripts per wave.
  60. - Give each producer a single responsibility such as feature generation, embedding extraction, fold training, checkpoint training, model distillation, or inference.
  61. - For code competitions, prefer producer notebooks that train models/checkpoints and export them as private Kaggle datasets; the final consumer should attach those datasets, load models from `/kaggle/input/...`, and perform hidden-test-safe inference.
  62. - Save producer notebook outputs as versioned private Kaggle datasets for durable reuse and as stable inputs to downstream notebooks; use direct `kernel_sources` only for short-lived chains where durability/versioning is unnecessary.
  63. - Run one final consumer notebook/script that attaches the produced datasets, reads their artifacts, writes the final OOF, test predictions, blend/stack report, and submission, then submit that final artifact/kernel to Kaggle for scoring.
  64. - Use `kagglehub` inside Python when it is more convenient to download datasets, competition files, notebook outputs, or upload dataset versions programmatically.
  65. ## Kaggle GPU quota accounting: avoid the SDK duration serialization bug
  66. Never calculate GPU availability using `str(response)`, `json.loads(str(response))`, serialized SDK duration strings, or `timedelta.seconds`.
  67. Kaggle SDK serialization can drop whole days: 30 hours becomes 6 hours. This previously caused an incorrect claim that GPU quota was exhausted.
  68. Read the live SDK duration objects and use `.total_seconds()` for each field:
  69. ```python
  70. allowed_seconds = allowed.total_seconds()
  71. used_seconds = used.total_seconds()
  72. reserved_seconds = reserved.total_seconds()
  73. remaining_seconds = allowed_seconds - used_seconds - reserved_seconds
  74. remaining_hours = remaining_seconds / 3600
  75. ```
  76. Fetch the current allowance, usage, reservations, and reset time each time. Do not hard-code the weekly allowance. Report all three inputs alongside the calculated remaining hours and reset time.
  77. If SDK values conflict with the Kaggle UI or look inconsistent, verify using authenticated:
  78. ```text
  79. GET https://www.kaggle.com/api/v1/kernels/quota
  80. ```
  81. Alternatively:
  82. ```text
  83. GET https://api.kaggle.com/v1/kernels/quota
  84. ```
  85. For raw duration objects, convert with:
  86. ```python
  87. seconds = duration["seconds"] + duration.get("nanos", 0) / 1e9
  88. ```
  89. Preserve whole days and fractional seconds throughout the calculation. Missing fields or request failures mean quota is unverified, not zero.
  90. Regression check: an allowance of 30 hours, usage of 7.5 hours, and reservations of 2 hours must yield 20.5 hours remaining. Never declare quota exhausted based on lossy SDK text.
  91. ## Definition Of Done
  92. Do not stop at a plan, scaffold, trained model, notebook run, downloaded output, or local validation score. Continue until one of these is true:
  93. - A competition submission has been sent to Kaggle, Kaggle has processed it, and the public score or submission status has been retrieved and recorded.
  94. - A code-competition final notebook/kernel has consumed all required producer artifacts, has been submitted with its kernel/version reference, and the resulting submission status/score has been retrieved and recorded.
  95. - A concrete external blocker prevents scoring: missing Kaggle credentials, rules not accepted, quota exhausted after retry attempts, competition closed, scoring disabled, required manual UI-only action, unavailable kernel version, or Kaggle service failure. Record the exact blocker and the next command/action needed.
  96. GPU quota exhaustion is a blocker only after verification using the GPU quota accounting rule above. Unverified quota must not be reported as exhausted.
  97. ## Validation Choices
  98. Use this quick mapping:
  99. - Balanced classification: `StratifiedKFold`.
  100. - Imbalanced classification: stratified folds plus metric-sensitive thresholding or class weights.
  101. - Regression: `KFold` for ordinary targets, binned stratified folds for skewed or multimodal targets.
  102. - Same user, patient, product, session, document, or image source appears multiple times: `GroupKFold` or stratified group splitting.
  103. - Ordered events or forecasting: time split, expanding-window validation, or competition-specific period split.
  104. - Images from same subject or scene: group by subject/scene before augmentation.
  105. - Text with duplicated sources, authors, questions, products, or prompts: group by source key.
  106. - Tiny data: repeated folds or more folds, but keep the final model selection discipline strict.
  107. ## Modeling Priorities
  108. - For tabular competitions, prefer tree boosting first unless the data is mostly sparse text or high-cardinality categorical interactions. Add CatBoost when categorical columns are central.
  109. - For linear models and neural networks, scale numeric features and encode categoricals carefully.
  110. - For tree models, start with label/count/frequency encodings and sensible missing values; scaling is usually unnecessary.
  111. - For target encoding, always compute encodings out-of-fold, with smoothing and no validation-row target visibility.
  112. - For image tasks, get dataset, transforms, labels, masks, and metric correct before changing architecture.
  113. - For text tasks, keep a TF-IDF baseline even when using transformers; it is fast, interpretable, and often blends well.
  114. - For hyperparameter search, tune only after folds and baselines are trustworthy. Search learning rate, depth/leaves, regularization, sampling, and number of estimators with early stopping.
  115. ## Competition Hygiene
  116. - Keep raw data read-only.
  117. - Keep competition data, private datasets, model checkpoints, downloaded outputs, submissions, credentials, and data-derived artifacts out of public Git repositories unless the competition rules and artifact licenses explicitly allow public redistribution.
  118. - Put all experiment-changing values in config or command-line args.
  119. - Seed Python, NumPy, framework, and model libraries when possible.
  120. - Save model files, OOF predictions, test predictions, fold scores, feature lists, and submission files with run IDs.
  121. - For Kaggle-offloaded jobs, write retrievable logs and artifacts into the notebook working directory, including run ID, git commit, config, fold, metric, hardware, elapsed time, OOM notes, and output file paths.
  122. - For multi-notebook pipelines, maintain a pipeline manifest with producer kernel refs, produced dataset refs, dataset versions, artifact schemas, metrics, and the final consumer run ID.
  123. - Keep producer datasets, kernels, and model artifacts private by default. Make them public only after verifying the target competition rules, data license, third-party IP, and user intent.
  124. - Record submission message, submission command or kernel/version, Kaggle submission timestamp, status, public score if available, and any error returned by Kaggle.
  125. - For vague code-competition failures, record the observed status, available logs, suspected failure class, patch attempted, and next retry command.
  126. - Never train a stacker on in-sample base predictions.
  127. - Never select features, target encoders, scalers, thresholds, or augmentations using validation targets outside the fold boundary.
  128. - Prefer scripts for repeatable training and notebooks for exploration and plots.
  129. ## Useful Commands
  130. Create a competition skeleton:
  131. ```bash
  132. python3 <skill-dir>/scripts/scaffold_competition.py --root .
  133. ```
  134. Create stratified folds:
  135. ```bash
  136. python3 <skill-dir>/scripts/make_folds.py \
  137. --input input/train.csv \
  138. --output input/train_folds.csv \
  139. --target target \
  140. --strategy stratified \
  141. --n-splits 5
  142. ```
  143. Create grouped folds:
  144. ```bash
  145. python3 <skill-dir>/scripts/make_folds.py \
  146. --input input/train.csv \
  147. --output input/train_folds.csv \
  148. --target target \
  149. --group-col patient_id \
  150. --strategy group
  151. ```
  152. Prepare a Kaggle GPU kernel experiment folder:
  153. ```bash
  154. python3 <skill-dir>/scripts/prepare_kaggle_kernel.py \
  155. --output kaggle_kernels/exp_lgbm_gpu \
  156. --username kaggle-user \
  157. --slug exp-lgbm-gpu \
  158. --title "exp lgbm gpu" \
  159. --competition playground-series-sample \
  160. --accelerator NvidiaTeslaT4
  161. ```
  162. Prepare a private Kaggle dataset folder for intermediate artifacts:
  163. ```bash
  164. python3 <skill-dir>/scripts/prepare_kaggle_dataset.py \
  165. --output kaggle_datasets/exp_features_v1 \
  166. --username kaggle-user \
  167. --slug exp-features-v1 \
  168. --title "exp features v1" \
  169. --description "OOF-safe feature artifacts for experiment exp_features_v1"
  170. ```
  171. Prepare a private Kaggle dataset folder for trained model artifacts:
  172. ```bash
  173. python3 <skill-dir>/scripts/prepare_kaggle_dataset.py \
  174. --output kaggle_datasets/exp_model_v1 \
  175. --username kaggle-user \
  176. --slug exp-model-v1 \
  177. --title "exp model v1" \
  178. --description "Trained model artifacts for experiment exp_model_v1" \
  179. --artifact-kind model
  180. ```
README.md · README · 303 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <div align="center">
  2. <img src="https://img.shields.io/badge/Agentic-AI%20Driven%20Kaggle-9cf?style=for-the-badge&logo=kaggle&logoColor=white" alt="Agentic Kaggle"/>
  3. <br>
  4. # Agentic Kaggle Skill
  5. # 智能体驱动的 Kaggle Skill
  6. <p align="center">
  7. <strong>Turn AI agents into Kaggle teammates</strong><br>
  8. <strong>让 AI 智能体成为你的 Kaggle 队友</strong>
  9. <br/>
  10. <sub>Reusable workflow for validation, modeling, Kaggle execution, debugging, ensembling, and scored submission.</sub><br>
  11. <sub>覆盖验证、建模、Kaggle 执行、调试、集成和最终得分提交的可复用工作流。</sub>
  12. </p>
  13. <p align="center">
  14. <a href="#what-it-does--这个-skill-能做什么">What It Does</a> |
  15. <a href="#install--安装">Install</a> |
  16. <a href="#repository-layout--仓库结构">Layout</a> |
  17. <a href="#attribution-and-safety--归属与安全">Safety</a>
  18. </p>
  19. <p align="center">
  20. <img src="https://img.shields.io/github/stars/FrankS-IntelLab/agentic-kaggle-skill?style=social" alt="GitHub stars"/>
  21. <img src="https://img.shields.io/github/forks/FrankS-IntelLab/agentic-kaggle-skill?style=social" alt="GitHub forks"/>
  22. </p>
  23. **Distilled from real Kaggle competition experience**
  24. **提炼自真实 Kaggle 竞赛实践**
  25. Including: **RL Game AI** | **Audio Classification** | **LLM Reasoning** | Multi-stage debugging journeys
  26. 包括:**强化学习游戏 AI** | **音频分类** | **LLM 推理** | 多阶段调试实践
  27. </div>
  28. ## Supported Agents / 支持的智能体
  29. | Agent | Status 状态 | Notes 说明 |
  30. | --- | --- | --- |
  31. | Codex | First-class 一等支持 | Uses `SKILL.md`, `agents/openai.yaml`, `references/`, and `scripts/`. |
  32. | Hermes | Supported 支持 | Uses the same skill folder. Hermes-era examples remain in `references/research/`. |
  33. ## Canonical Skill Identity / 统一 Skill 名称
  34. This repository keeps one canonical skill identity:
  35. 本仓库使用一个统一的 skill 名称:
  36. ```yaml
  37. name: agentic-kaggle-skill
  38. ```
  39. The skill is written in the open agent skills format so it can be used by multiple agents. Codex-specific metadata lives in `agents/openai.yaml`; Hermes users can consume the same root `SKILL.md` and bundled resources.
  40. 该 skill 使用开放 agent skill 格式编写,可被多个智能体使用。Codex 专属元数据放在 `agents/openai.yaml`;Hermes 用户可以直接使用根目录的 `SKILL.md` 以及配套的 `references/` 和 `scripts/`。
  41. ## What It Does / 这个 Skill 能做什么
  42. Transform Kaggle work from scattered manual iteration into an agent-assisted competition loop:
  43. 将 Kaggle 工作从零散的手动试错转为智能体辅助的竞赛闭环:
  44. | Before 之前 | After 之后 |
  45. | --- | --- |
  46. | Manual notebook analysis 手动分析 notebook | Agent scouts public notebooks and discussions as signals 智能体将公开 notebook 和讨论作为线索 |
  47. | Guess why submissions fail 猜测提交失败原因 | Agent diagnoses format, path, runtime, and hidden rerun issues 智能体诊断格式、路径、运行时和隐藏重跑问题 |
  48. | Try random improvements 随机尝试改进 | Fold-driven validation and OOF-safe iteration 基于 fold 和 OOF 的稳健迭代 |
  49. | One overloaded notebook 一个超载 notebook | Producer/consumer pipeline with private artifact datasets 使用私有 artifact dataset 的生产者/消费者流水线 |
  50. Core capabilities:
  51. 核心能力:
  52. - Read Kaggle rules, data terms, metric, submission format, and scoring mode before modeling.
  53. 建模前先阅读竞赛规则、数据条款、指标、提交格式和评分模式。
  54. - Build metric-correct baselines with stable folds and out-of-fold predictions.
  55. 构建指标正确、fold 稳定、带 OOF 预测的 baseline。
  56. - Use public notebook and discussion intelligence as scouting signals, not copied source.
  57. 将公开 notebook 和讨论作为侦察信号,而不是直接复制来源。
  58. - Offload heavy work to Kaggle notebooks/scripts when local compute is insufficient.
  59. 本地算力不足时,将重任务转移到 Kaggle notebook/script。
  60. - Support staged producer/consumer notebook pipelines with private artifact datasets.
  61. 支持带私有 artifact dataset 的多阶段生产者/消费者 notebook 流水线。
  62. - Handle code-competition hidden rerun failures, vague scoring errors, timeouts, and OOMs.
  63. 处理代码竞赛隐藏重跑失败、模糊评分错误、超时和 OOM。
  64. - Track reproducibility artifacts, run logs, score receipts, and ensemble evidence.
  65. 记录可复现 artifact、运行日志、提交回执和集成证据。
  66. - Continue toward a scored Kaggle submission or record a concrete blocker.
  67. 持续推进到 Kaggle 得分提交,或记录明确阻塞原因。
  68. ## Install / 安装
  69. ### Codex
  70. Install as a user-level Codex skill:
  71. 作为用户级 Codex skill 安装:
  72. ```bash
  73. mkdir -p ~/.agents/skills
  74. git clone https://github.com/FrankS-IntelLab/agentic-kaggle-skill.git \
  75. ~/.agents/skills/agentic-kaggle-skill
  76. ```
  77. Restart Codex if the skill does not appear immediately. Invoke it explicitly with:
  78. 如果 skill 没有立即出现,请重启 Codex。可以这样显式调用:
  79. ```text
  80. Use $agentic-kaggle-skill to help me start this Kaggle competition.
  81. ```
  82. For repo-scoped development, place or symlink this folder under a repository's `.agents/skills/` directory:
  83. 如果只想在某个仓库中启用,可以把该目录放到或软链接到仓库的 `.agents/skills/`:
  84. ```bash
  85. mkdir -p .agents/skills
  86. ln -s /path/to/agentic-kaggle-skill .agents/skills/agentic-kaggle-skill
  87. ```
  88. ### Hermes
  89. Install the whole skill folder so references and scripts are available:
  90. 安装完整 skill 目录,确保 references 和 scripts 都可用:
  91. ```bash
  92. mkdir -p ~/.hermes/skills/data-science
  93. git clone https://github.com/FrankS-IntelLab/agentic-kaggle-skill.git \
  94. ~/.hermes/skills/data-science/agentic-kaggle
  95. ```
  96. Then ask Hermes to use the agentic Kaggle skill for competition work.
  97. 然后让 Hermes 使用 agentic Kaggle skill 来处理竞赛任务。
  98. ### Helper Script Dependencies / 辅助脚本依赖
  99. Most scripts use only the Python standard library. `scripts/make_folds.py` requires pandas and numpy; scikit-learn is recommended for standard splitters.
  100. 大部分脚本只依赖 Python 标准库。`scripts/make_folds.py` 需要 pandas 和 numpy;推荐安装 scikit-learn 以使用标准切分器。
  101. ```bash
  102. python3 -m pip install -r requirements.txt
  103. ```
  104. ## Repository Layout / 仓库结构
  105. ```text
  106. agentic-kaggle-skill/
  107. ├── SKILL.md
  108. ├── agents/
  109. │ └── openai.yaml
  110. ├── references/
  111. │ ├── method-map.md
  112. │ ├── information-sharing-policy.md
  113. │ ├── competition-intel.md
  114. │ ├── cross-validation-and-metrics.md
  115. │ ├── tabular-workflow.md
  116. │ ├── image-text-workflow.md
  117. │ ├── kaggle-code-competition-pipeline.md
  118. │ ├── advanced-notebook-architecture.md
  119. │ ├── kaggle-offload.md
  120. │ ├── kaggle-pipeline-datasets.md
  121. │ ├── submission-endgame.md
  122. │ ├── code-competition-debugging.md
  123. │ ├── ensembling-and-reproducibility.md
  124. │ └── research/
  125. ├── scripts/
  126. │ ├── scaffold_competition.py
  127. │ ├── make_folds.py
  128. │ ├── prepare_kaggle_kernel.py
  129. │ └── prepare_kaggle_dataset.py
  130. ├── examples/
  131. │ ├── rl-game-case-study.md
  132. │ └── audio-classification-case-study.md
  133. ├── requirements.txt
  134. ├── README.md
  135. └── LICENSE
  136. ```
  137. ## Case Studies / 案例研究
  138. ### RL Strategy Game Competition / 强化学习策略游戏竞赛
  139. | Lesson 教训 | Details 详情 |
  140. | --- | --- |
  141. | Feature completeness 功能完整性 | Top agents used much richer decision logic; simplified agents underperformed. 顶级 agent 使用更完整的决策逻辑,简化版表现明显较弱。 |
  142. | Time budget 时间预算 | Strict turn limits require profiling after each change. 严格回合限制要求每次改动后都做性能分析。 |
  143. [Full case study / 完整案例](examples/rl-game-case-study.md)
  144. ### Audio Classification Competition / 音频分类竞赛
  145. | Lesson 教训 | Details 详情 |
  146. | --- | --- |
  147. | Hybrid ensemble 混合集成 | Temporal model plus SED-style models can improve robustness. 时序模型加 SED 风格模型可提升稳健性。 |
  148. | Silent failures 静默失败 | Log exceptions during feature extraction and inference. 特征提取和推理阶段需要记录异常。 |
  149. [Full case study / 完整案例](examples/audio-classification-case-study.md)
  150. ## Design Notes / 设计说明
  151. `SKILL.md` is the canonical entry point. It stays concise and tells the agent which reference file to load for each Kaggle workflow.
  152. `SKILL.md` 是统一入口,保持简洁,并告诉智能体在不同 Kaggle 工作流中应该加载哪个参考文件。
  153. `agents/openai.yaml` is Codex-facing UI metadata. It does not fork the workflow; it only improves how the skill appears and is invoked in Codex.
  154. `agents/openai.yaml` 是面向 Codex 的 UI 元数据,不分叉工作流,只改善该 skill 在 Codex 中的展示与调用体验。
  155. `references/` contains detailed workflow guidance loaded only when relevant. The `references/research/` folder preserves earlier Hermes-era lessons, troubleshooting notes, automation patterns, and case-specific insights.
  156. `references/` 存放按需加载的详细流程说明。`references/research/` 保留早期 Hermes 阶段的经验、故障排除、自动化模式和具体案例洞察。
  157. `scripts/` contains repeatable utilities for scaffolding a Kaggle project, making folds, preparing Kaggle kernels, and preparing private Kaggle artifact datasets.
  158. `scripts/` 存放可复用工具,用于创建 Kaggle 项目骨架、生成 folds、准备 Kaggle kernels,以及准备私有 Kaggle artifact datasets。
  159. ## Attribution And Safety / 归属与安全
  160. This skill is source-agnostic. It packages general competitive ML and Kaggle workflow procedures rather than copying named public notebooks, books, or papers.
  161. 该 skill 是 source-agnostic 的。它封装的是通用竞赛机器学习和 Kaggle 工作流流程,而不是复制某个公开 notebook、书籍或论文。
  162. When using public notebooks or discussions during an active competition, treat them as scouting signals. Do not copy code, text, model artifacts, generated features, or data-derived outputs without checking the competition rules, data license, third-party license obligations, and attribution requirements.
  163. 在进行中的竞赛中使用公开 notebook 或讨论时,应将其视作侦察信号。不要在未检查竞赛规则、数据许可、第三方许可证义务和归属要求前复制代码、文本、模型 artifact、生成特征或数据派生输出。
  164. ## Development / 开发维护
  165. Keep the public identity aligned everywhere:
  166. 请保持所有位置的公开名称一致:
  167. ```text
  168. agentic-kaggle-skill
  169. ```
  170. When updating the skill:
  171. 更新 skill 时:
  172. 1. Keep the canonical workflow in `SKILL.md`.
  173. 将统一工作流保留在 `SKILL.md`。
  174. 2. Put detailed procedure in `references/`.
  175. 将详细流程放入 `references/`。
  176. 3. Put deterministic helpers in `scripts/`.
  177. 将确定性辅助工具放入 `scripts/`。
  178. 4. Regenerate or update `agents/openai.yaml` when the skill name, scope, or default prompt changes.
  179. 当 skill 名称、范围或默认 prompt 变化时,更新 `agents/openai.yaml`。
  180. 5. Validate the skill metadata before release.
  181. 发布前验证 skill 元数据。
  182. ## Why Star This Repo? / 为什么 Star?
  183. - Battle-tested patterns from real competitions.
  184. 来自真实竞赛的实战模式。
  185. - Bilingual documentation for English and Chinese users.
  186. 面向英文与中文用户的双语文档。
  187. - Practical troubleshooting for common Kaggle issues.
  188. 覆盖常见 Kaggle 问题的实用故障排除。
  189. - Codex-ready organization with Hermes compatibility.
  190. Codex-ready 的组织方式,同时兼容 Hermes。
  191. - Case studies with concrete competition lessons.
  192. 带有具体竞赛经验的案例研究。
  193. ## Contributing / 贡献
  194. Found a new pattern or solved a tricky error?
  195. 发现了新模式或解决了棘手错误?
  196. 1. Fork the repo.
  197. Fork 仓库。
  198. 2. Add your insight to `references/research/`, `references/`, or `examples/`.
  199. 将你的洞察添加到 `references/research/`、`references/` 或 `examples/`。
  200. 3. Submit a pull request.
  201. 提交 PR。
  202. ## License / 许可证
  203. MIT. See `LICENSE`.
  204. MIT。见 `LICENSE`。
  205. <div align="center">
  206. **Made by [Frank S (IntelLab)](https://github.com/FrankS-IntelLab)**
  207. **由 [Frank S (IntelLab)](https://github.com/FrankS-IntelLab) 创建**
  208. [![Kaggle](https://img.shields.io/badge/Kaggle-franksunp-blue?logo=kaggle)](https://www.kaggle.com/franksunp)
  209. [![GitHub](https://img.shields.io/badge/GitHub-FrankS--IntelLab-black?logo=github)](https://github.com/FrankS-IntelLab)
  210. <br>
  211. *If this skill helped your Kaggle journey, star the repo.*
  212. *如果这个 skill 帮助了你的 Kaggle 旅程,欢迎 Star 这个仓库。*
  213. </div>

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.