kaggle-grandmaster

Plugin kaggle-grandmaster from marketplace claude-code-kaggle-grandmaster in TranBaDat2607/claude-code-kaggle-grandmaster. Commands read from the repo's manifest — 3 days ago.

Skills (40)

• audio-and-signal

  Playbook for Kaggle audio and biosignal competitions — bioacoustics (BirdCLEF-style), speech, EEG/ECG/EMG, seismic and other 1D signals — covering spectrogram vs raw-waveform models, augmentation, weak labels, soundscape inference under CPU limits, and subject-grouped validation. Use for any audio o

• code-competitions

  Shipping solutions to Kaggle code competitions — offline notebooks with internet disabled, packaging models/wheels/code as Kaggle datasets, hidden test set re-runs, runtime and memory budgets on T4x2/P100/L4/TPU/CPU, evaluation API patterns, and debugging submission errors (Scoring Error, timeout, O

• competition-recon

  How to analyse a Kaggle competition before modelling — metric, data, rules, timeline, public notebooks, discussions, leaks, past similar competitions and shake-up risk. Use at the start of a competition, when joining late, or when the user asks to research/understand a competition.

• competition-strategy

  The career layer of becoming a Kaggle Competitions Grandmaster — what the title requires (golds, a solo gold), which competitions award medals and which to enter, planning a solo gold, joining late, running several competitions at once, and teaming — when and with whom to merge, the private-sharing

• compute-efficiency

  Speed defaults for Kaggle training and inference by domain (images, text and LLMs, tabular with cuDF/cuML/GPU GBDTs, audio, recsys, time series) and hardware (T4x2, P100, TPU, CPU-only kernels, Windows): measuring idle, input-bound or compute-bound runs, mixed precision, data loading, torch.compile,

• computer-vision

  Winning playbook for Kaggle computer vision competitions — image classification, object detection, segmentation, medical imaging (CT/MRI/X-ray/pathology), video, satellite — covering backbone choice (timm), resolution, augmentations, losses, training recipes, TTA, pseudo-labelling, multi-stage pipel

• cv-lb-debugging

  Systematic diagnosis when cross-validation and leaderboard disagree, when a score is suspiciously good or bad, or when an improvement in CV does not transfer to LB — leakage hunting, distribution shift analysis, inference/training mismatch, metric bugs, and public LB noise estimation. Use when CV an

• deep-learning-training

  Competition-grade deep learning training practice in PyTorch — schedules, optimisers, mixed precision, EMA/SWA, gradient accumulation and checkpointing, multi-GPU on Kaggle (2xT4), data loading speed, reproducibility, debugging loss curves, and making the most of limited GPU hours. Use when writing

• ensembling

  How Kaggle Grandmasters build ensembles — OOF management, diversity, averaging/rank/geometric blending, Caruana hill climbing, constrained weight optimisation, stacking with nested CV, multi-level and residual stacking over large model libraries, library pruning, multi-seed and multi-fold averaging,

• final-submission-selection

  Choosing the final Kaggle submissions to maximise expected private leaderboard score and survive shake-ups — CV vs public LB weighting, hedging strategies, robustness checks, and endgame timeline. Use in the last days of a competition or when the user asks which submissions to select.

• grandmaster-playbook

  The master operating procedure for competing in a Kaggle (or Kaggle-style) machine learning competition at Grandmaster level. Use whenever the user is working on a Kaggle competition, wants to improve a leaderboard score, asks how to approach a data science competition, or is in a workspace containi

• hyperparameter-tuning

  Efficient hyperparameter optimisation for Kaggle — when tuning is worth it, Optuna recipes with pruning on frozen folds, search spaces for LightGBM/XGBoost/CatBoost/NNs/transformers, budget allocation, and avoiding CV overfitting from excessive search. Use when the user wants to tune models or asks

• kaggle-cli

  Using the official Kaggle CLI/API from Claude Code — authentication, downloading competition data, submitting (and reading scores), listing submissions and leaderboards, pushing/pulling notebooks (kernels), creating and versioning datasets and models, and fetching episode replays. Use whenever inter

• kaggle-gpu

  Training on Kaggle's free GPUs and TPUs under their weekly quotas — choosing T4x2, P100, TPU v5e-8 or a CPU kernel, remote training runs with kgkit gpu (build/push/wait/collect), one-fold screens with pruning, resuming past the session limit, porting to torch_xla, and budgeting accelerator hours unt

• kg-adopt

  Adopt an existing mid-competition Kaggle repo in place — write .kaggle-gm/ (competition facts), import the past Kaggle submissions and the experiments the repo already tracks, mark the accepted baseline — so the hooks, budget checks and kgkit work. Use instead of kg-start when the competition work a

• kg-baseline

  Build fast, strong, correctly-validated baselines for the current competition from the plugin's templates — the main model plus diverse families on the same folds — log them to the ledger, decide the accepted baseline and produce a validated submission file.

• kg-cv

  Design, build, verify and freeze the cross-validation scheme (data/folds.csv) so it mirrors how the test set was split.

• kg-debug

  Diagnose a CV-LB disagreement, a suspicious score jump, or a failed/odd submission using the systematic CV-LB debugging procedure and the validation auditor.

• kg-eda

  Competition-focused EDA — red flags, leaks, drift, hidden groups, adversarial validation — written to reports/eda.md.

• kg-ensemble

  Build the best honest ensemble from ledger experiments (diversity analysis, hill climbing / weights / rank / stacking with nested CV, post-processing re-tune) and write a validated blended submission.

• kg-experiment

  Run one disciplined experiment for a hypothesis — single change, frozen folds, same seeds, ledger logging with its parent baseline, paired comparison (per-fold deltas + OOF bootstrap) against the accepted baseline, recorded keep/discard decision.

• kg-final

  Choose the final Kaggle submissions to maximise expected private leaderboard score — evidence table, LB noise estimate, CV-vs-LB weighting, hedge selection and robustness checks.

• kg-gpu

  Run training on Kaggle's GPUs within the weekly quota — plan the GPU budget, screen ideas on one fold (two per 2xT4 session, with pruning), promote winners to full-fold remote runs, resume timed-out runs, collect results into the ledger with GPU-hour accounting.

• kg-grind

  Autonomous improvement loop — repeatedly pick the highest-value idea from the backlog, run it as a disciplined experiment against the accepted baseline, decide with a paired comparison, update the backlog, and re-check the CV for overfitting, within a time or experiment budget.

• kg-ideas

  Generate a ranked, evidence-backed backlog of next experiments from error analysis, the domain playbook's untried levers, public notebooks, discussion/prior-art research and the ledger history, stored with kgkit backlog.

• kg-kernel

  Package the current best solution for a Kaggle code competition — offline inference script, weight/code/wheel datasets, kernel metadata with internet off, runtime estimate on hidden-test size, push and poll.

• kg-postmortem

  After a competition ends — record every public and private score, check what the finals scored, measure which signals predicted the private leaderboard, study the top solutions, and distil reusable lessons into a post-mortem and a cross-competition lessons file.

• kg-recon

  Research a Kaggle competition (metric, data, rules, timeline, top notebooks, discussions, similar past competitions, leak and shake-up risk) and write reports/recon.md.

• kg-showcase

  After a competition ends — turn the work into a public repository with two ways in. solution/ for readers who want the result (the final pipeline and the exact commands), journey/ for readers who want to learn from it (how the ideas developed, phase by phase, written from the ledger, with links to t

• kg-start

  Bootstrap a Kaggle competition workspace end to end — recon, data download, workspace init, EDA, adversarial validation, frozen folds, metric implementation, baseline model and a first validated submission file.

• kg-status

  Show where the competition stands — metric, deadline, accepted baseline, best CV, best LB, CV-LB correlation, recent experiments and decisions, top of the backlog, submissions left today — and recommend the next actions.

• kg-submit

  Validate a submission file, check the daily budget, submit it to Kaggle with a ledger-linked message, poll for the public score and record it in the ledger.

• leaderboard-boosters

  Advanced techniques that move a solid solution into the medal zone — pseudo-labelling, knowledge distillation, test-time augmentation, external data and pretraining, data cleaning/relabelling, multi-stage pipelines, auxiliary targets, leak exploitation, and full-data retraining. Use when a strong ba

• metric-optimization

  Optimising directly for the Kaggle evaluation metric — choosing training losses that align with AUC, logloss, RMSE/RMSLE/MAE, F1/F-beta, QWK, MAP@K, IoU/Dice, mAP, pinball and custom metrics; threshold and rounding optimisation, calibration, metric-aware post-processing and exact metric re-implement

• nlp-and-llm

  Winning playbook for Kaggle NLP and LLM competitions — transformer fine-tuning (DeBERTa-v3 and friends), LLM fine-tuning with LoRA/QLoRA, LLM-as-solver (math/reasoning/agents), retrieval & RAG, synthetic data generation, distillation, efficient inference with vLLM under Kaggle time limits, and text-

• recsys-and-ranking

  Playbook for Kaggle recommendation and ranking competitions (OTTO, H&M, session-based recommendation, search relevance, learning-to-rank) — candidate generation (co-visitation, recency, popularity, embeddings), feature engineering for user-item pairs, LambdaRank/GBDT rankers, MAP@K/NDCG/recall valid

• simulation-and-optimization

  Playbook for Kaggle simulation competitions (agents playing games in an environment against other teams' bots, e.g. Lux AI, Kore, ConnectX, Halite) and combinatorial optimisation competitions (Santa / traveling-salesman / scheduling / packing puzzles). Use when the submission is an agent or a soluti

• tabular-mastery

  Winning playbook for tabular Kaggle competitions (including Playground Series) — GBDT (LightGBM, XGBoost, CatBoost) recipes, feature engineering patterns, categorical handling, NN models for tabular (MLP, TabM, transformers), GPU acceleration, synthetic-data competitions, and tabular ensembling. Use

• time-series

  Winning playbook for Kaggle time-series and forecasting competitions — leak-free time validation, lag/rolling/calendar features, global GBDT models, recursive vs direct multi-horizon forecasting, hierarchical reconciliation, deep forecasting models, financial/market prediction with purged CV, and se

• validation-strategy

  Designing a cross-validation scheme that tracks the private leaderboard — choosing KFold/Stratified/Group/StratifiedGroup/multilabel/time-series/purged splits, adversarial validation, CV-LB correlation, noise estimation, and leakage prevention. Use when setting up CV, when CV and LB disagree, or bef

Subagents (9)

• competition-analyst

  Researches a Kaggle competition end to end — overview, evaluation metric, data description, rules, timeline, leaderboard, top public notebooks and discussion threads — and writes reports/recon.md plus a filled .kaggle-gm/competition.json. Use at the start of a competition or when joining one late.

• data-detective

  Performs competition-focused exploratory data analysis — target analysis, train/test drift, adversarial validation, leak hunting (IDs, ordering, duplicates, metadata), hidden group structure, label noise — and writes reports/eda.md with ranked red flags and opportunities. Use after downloading data

• ensemble-architect

  Builds the strongest honest ensemble from the experiment ledger — audits that candidate OOFs share folds and row order, prunes near-duplicates in large libraries, analyses correlation/diversity, runs hill climbing, weight optimisation, rank blending, multi-level and residual stacking with honest sco

• error-analyst

  Analyses out-of-fold errors of the accepted baseline (or a named model) — worst-loss samples, error slices by feature/group/class, confusion patterns, calibration, label noise candidates — and turns them into a ranked list of concrete experiment ideas. Use when progress stalls or to decide what to t

• experiment-runner

  Executes one well-defined competition experiment end to end — implement the change, run training on the frozen folds, log CV/fold scores/OOF/test predictions to the ledger, and decide keep/discard with a paired comparison against the accepted baseline. Use to delegate a single hypothesis test (e.g.

• feature-engineer

  Designs, implements and ablates feature families for tabular / time-series competitions (domain ratios, group aggregates, OOF target encoding, count encoding, lags/rolling, text-in-table features), runs brute-force feature search (thousands of generated candidates screened on the frozen folds), and

• kernel-packager

  Packages a solution for a Kaggle code competition — builds the offline inference notebook/script, uploads model weights, code and wheels as Kaggle datasets, writes kernel-metadata.json with internet disabled, estimates runtime on the hidden test, and pushes/polls the kernel. Use when preparing or de

• solution-researcher

  Mines winning solutions of past Kaggle competitions similar to the current one (top-place write-ups, discussion posts, GitHub repos, papers) and returns a structured digest of techniques that repeatedly won, with expected impact and cost. Use when planning an approach, when stuck, or after a competi

• validation-auditor

  Skeptical reviewer that audits training/feature/inference code and fold assignment for target leakage, group or temporal leakage, preprocessing fit outside folds, post-processing tuned on reported OOF, train/inference mismatch, and metric bugs. Use before trusting a big CV jump, when CV and LB disag

Hooks (5)

• SessionStart

  sh "${CLAUDE_PLUGIN_ROOT}/hooks/run.sh" session_start.py

• PreToolUse

  sh "${CLAUDE_PLUGIN_ROOT}/hooks/run.sh" pre_tool.py

• PostToolUse

  sh "${CLAUDE_PLUGIN_ROOT}/hooks/run.sh" post_tool.py

• PostToolUse

  sh "${CLAUDE_PLUGIN_ROOT}/hooks/run.sh" post_write.py

• UserPromptSubmit

  sh "${CLAUDE_PLUGIN_ROOT}/hooks/run.sh" prompt_router.py

Similar plugins