Datasets:

GPUMODE
/

kernelbot-data

@@ -1,86 +1,27 @@
 ---
 configs:
-- config_name: amd_submissions
   data_files: "submissions.parquet"
-- config_name: amd_successful_submissions
   data_files: "successful_submissions.parquet"
-- config_name: nvidia_nvfp4_submissions
-  data_files: "nvidia_nvfp4_submissions.parquet"
 - config_name: leaderboards
   data_files: "leaderboards.parquet"
 tags:
 - code
-license: cc-by-4.0
 ---
-# KernelBot Competition Data
-This dataset contains GPU kernel submissions from the KernelBot competition platform. Submissions are optimized GPU kernels written for specific hardware targets.
-## Data Files
-### AMD MI300 Submissions
-| File | Description |
-|------|-------------|
-| `submissions.parquet` | All AMD competition submissions |
-| `successful_submissions.parquet` | AMD submissions that passed correctness tests |
-| `deduplicated_submissions.parquet` | AMD submissions deduplicated by (user, code) |
-| `deduplicated_successful_submissions.parquet` | Deduplicated passing AMD submissions |
-**AMD Problems:** fp8-gemm, moe (mixture of experts), mla-decode, all2all, gemm+reducescatter, allgather+gemm
-### NVIDIA Blackwell NVFP4 Submissions
-| File | Size | Description |
-|------|------|-------------|
-| `nvidia_nvfp4_submissions.parquet` | ~1.4 GB | NVFP4 submissions deduplicated by (user, code), with full code content |
-**NVFP4 Problems:** gemv (leaderboard 595), gemm (597), dual_gemm (598), modal_dual_gemm (697)
-**Note on Dual GEMM:** There are two variants of the dual_gemm problem. Midway through the competition, on-prem hardware measurements became unreliable, so a second leaderboard was created on Modal infrastructure. The Modal measurements (leaderboard 697, `modal_nvfp4_dual_gemm`) are more trustworthy.
-**Note:** Scores are execution time in seconds. **Lower is better.**
-## Helper Scripts
-- `analyze_submissions.py` - Python functions for analyzing submissions
-- `skills.md` - Documentation for data processing workflows
-### Quick Start
-```python
-from analyze_submissions import load_submissions, top_contestants, author_progression
-# Load NVIDIA NVFP4 data
-df = load_submissions()
-# Get top 20 for a problem
-leaders = top_contestants(df, problem_name='nvfp4_gemm', n=20)
-# See a user's progression over time
-progression = author_progression(df, user_name='username', problem_name='nvfp4_gemm')
-```
-## Learn More
-- Competition platform: [gpumode.com](https://gpumode.com)
-- Reference kernels and problem specs: [github.com/gpu-mode/reference-kernels](https://github.com/gpu-mode/reference-kernels)
-## License
-This dataset is licensed under the [Creative Commons Attribution 4.0 International License (CC BY 4.0)](https://creativecommons.org/licenses/by/4.0/).
-You are free to share and adapt the material for any purpose, even commercially, provided you give appropriate credit.
-**Attribution:** Please cite GPU Mode and link to this dataset. For academic papers, use the citation below.
-## Citation
 If you use this dataset in your work, please cite:
 ```bibtex
 @inproceedings{
-  kernelbot2025,
   title={KernelBot: A Competition Platform for Writing Heterogeneous {GPU} Code},
   author={Alex L Zhang and Matej Sirovatka and Erik Schultheis and Benjamin Horowitz and Mark Saroufim},
   booktitle={Championing Open-source DEvelopment in ML Workshop @ ICML25},

 ---
 configs:
+- config_name: submissions
   data_files: "submissions.parquet"
+- config_name: successful_submissions
   data_files: "successful_submissions.parquet"
 - config_name: leaderboards
   data_files: "leaderboards.parquet"
 tags:
 - code
+license: mit
 ---
+This is the dataset that was created from the first and second AMD $100K kernel competitions, containing roughly 110K kernels for fp8-gemm, moe, mla, all2all, gemm+reducescatter, and allgather+gemm optimized to run on MI300. Learn more at gpumode.com/v2/news
+To see the full list of kernel competitions we've ran and are running you can checkout https://github.com/gpu-mode/reference-kernels which also contains details on reference kernels and their input shapes and distributions
+We are planning on adding kernels optimized for NVFP4 on Blackwell next
 If you use this dataset in your work, please cite:
 ```bibtex
 @inproceedings{
+  zhang2025kernelbot,
   title={KernelBot: A Competition Platform for Writing Heterogeneous {GPU} Code},
   author={Alex L Zhang and Matej Sirovatka and Erik Schultheis and Benjamin Horowitz and Mark Saroufim},
   booktitle={Championing Open-source DEvelopment in ML Workshop @ ICML25},

docs.md DELETED Viewed

@@ -1,158 +0,0 @@
-# Kernelbot Data Processing Skills
-This document describes how to extract and process submission data from the Kernelbot database.
-## Database Connection
-The production database is hosted on Heroku. **NEVER run write operations (INSERT, UPDATE, DELETE) on this database.**
-```bash
-# Get DATABASE_URL from Heroku
-heroku config:get DATABASE_URL --app discord-cluster-manager
-```
-## Database Schema
-The relevant tables are in the `leaderboard` schema:
-| Table | Description |
-|-------|-------------|
-| `leaderboard.leaderboard` | Problem definitions (id, name, deadline, task, description) |
-| `leaderboard.submission` | User submissions (id, leaderboard_id, user_id, code_id, submission_time, status) |
-| `leaderboard.runs` | Execution results (submission_id, score, passed, mode, runner, result) |
-| `leaderboard.user_info` | User details (id, user_name) |
-| `leaderboard.gpu_type` | GPU types per problem (leaderboard_id, gpu_type) |
-| `leaderboard.code_files` | Actual submission code content (old_code text, code bytea) |
-## Key Problem IDs
-### NVFP4 Problems
-- **595**: nvfp4_gemv
-- **597**: nvfp4_gemm
-- **598**: nvfp4_dual_gemm
-- **730**: nvfp4_group_gemm (not released yet)
-### AMD Problems
-- **398**: amd-identity
-- **399**: amd-fp8-mm
-- **430**: amd-mixture-of-experts
-- **463**: amd-mla-decode
-- **563**: amd-all2all
-- **564**: amd-gemm-rs
-- **565**: amd-ag-gemm
-## Run Modes
-| Mode | Description | Has Score? |
-|------|-------------|------------|
-| `test` | Correctness tests | No |
-| `benchmark` | Performance benchmarks (internal) | No |
-| `leaderboard` | Official leaderboard runs | **Yes** |
-| `profile.0-3` | Profiling runs | No |
-**Important:**
-- Use `mode = 'leaderboard'` when joining runs to get scores.
-- **Lower scores are better** (scores are execution time in seconds).
-## SQL Queries
-All SQL queries are in `queries.sql`. Key queries:
-- List all problems
-- Check submission counts
-- Export deduplicated submissions with code
-- Get top N submissions
-- Get user progression over time
-## Adding Support for a New Problem
-### Step 1: Find the Problem ID
-Use the "LIST ALL PROBLEMS" query from `queries.sql`.
-### Step 2: Check Submission Counts
-Use the "CHECK SUBMISSION COUNTS" query from `queries.sql`.
-### Step 3: Export Deduplicated Submissions
-Use the "EXPORT DEDUPLICATED SUBMISSIONS WITH CODE" query from `queries.sql`.
-```python
-import pandas as pd
-import psycopg2
-DATABASE_URL = "..."  # from heroku config:get
-conn = psycopg2.connect(DATABASE_URL)
-# Read query from queries.sql and modify problem IDs as needed
-with open('queries.sql') as f:
-    # Find and use the export query section
-    pass
-df = pd.read_sql(query, conn)
-df.to_parquet('new_problem_submissions.parquet', index=False)
-```
-### Step 4: Verify Data Quality
-```python
-from analyze_submissions import load_submissions, leaderboard_summary
-df = load_submissions('new_problem_submissions.parquet')
-print(leaderboard_summary(df))
-```
-## Accessing Submission Code
-The parquet files include the full code content for each submission:
-```python
-from analyze_submissions import load_submissions
-df = load_submissions()
-# Get a specific user's best submission
-user_subs = df[(df['user_name'] == 'gau.nernst') & (df['problem_name'] == 'nvfp4_gemv')]
-best = user_subs.sort_values('score').head(1)
-# Access the code
-code = best['code'].values[0]
-print(code)
-```
-## Helper Functions
-Use `analyze_submissions.py`:
-```python
-from analyze_submissions import (
-    load_submissions,      # Load parquet file
-    author_progression,    # See user's submissions over time
-    top_contestants,       # Get leaderboard rankings
-    leaderboard_summary,   # Summary stats per problem
-    user_stats,            # Stats for a specific user
-    format_score           # Format score with units (us, ms, s)
-)
-```
-## Environment Setup
-```bash
-uv venv .venv
-source .venv/bin/activate
-uv pip install pandas pyarrow psycopg2-binary
-```
-## Files
-| File | Description |
-|------|-------------|
-| `nvidia_nvfp4_submissions.parquet` | Deduplicated NVIDIA NVFP4 submissions with code (~1.4 GB) |
-| `queries.sql` | All SQL queries for data extraction |
-| `scripts/nvfp4/analyze_submissions.py` | Helper functions library |
-| `scripts/nvfp4/get_fastest_submission.py` | Print user's fastest submission |
-| `scripts/nvfp4/query_submissions.py` | List submission IDs or query specific ID |
-## Review Checklist Before Pushing
-1. Verify submission counts match expectations
-2. Check for any anomalies in scores (negative, extremely large, etc.)
-3. Confirm deduplication worked correctly
-4. Test helper functions work with the new data
-5. Run `python scripts/nvfp4/query_submissions.py` to verify

nvidia_nvfp4_submissions.parquet DELETED Viewed

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:64f4d29e68f3471b524be55a62f1af58a4d36a0f1f2d191c59a8f5302941e664
-size 1622580981

queries.sql DELETED Viewed

@@ -1,124 +0,0 @@
--- Kernelbot Database Queries
--- All queries are READ ONLY. Never run INSERT/UPDATE/DELETE on production.
--- Scores are execution time in seconds. Lower is better.
---------------------------------------------------------------------------------
--- LIST ALL PROBLEMS
---------------------------------------------------------------------------------
-SELECT
-    l.id,
-    l.name,
-    l.deadline,
-    l.description,
-    array_agg(g.gpu_type) as gpu_types
-FROM leaderboard.leaderboard l
-LEFT JOIN leaderboard.gpu_type g ON l.id = g.leaderboard_id
-GROUP BY l.id, l.name, l.deadline, l.description
-ORDER BY l.id;
---------------------------------------------------------------------------------
--- PROBLEM IDS
---------------------------------------------------------------------------------
--- NVFP4: 595 (gemv), 597 (gemm), 598 (dual_gemm), 730 (group_gemm)
--- AMD: 398 (identity), 399 (fp8-mm), 430 (moe), 463 (mla-decode),
---      563 (all2all), 564 (gemm-rs), 565 (ag-gemm)
---------------------------------------------------------------------------------
--- CHECK SUBMISSION COUNTS FOR A PROBLEM
---------------------------------------------------------------------------------
-SELECT
-    COUNT(*) as total_submissions,
-    COUNT(DISTINCT user_id) as unique_users
-FROM leaderboard.submission
-WHERE leaderboard_id = 595;  -- Replace with problem ID
---------------------------------------------------------------------------------
--- EXPORT DEDUPLICATED SUBMISSIONS WITH CODE
--- Deduplicates by (user_id, code_id), keeping the fastest score
---------------------------------------------------------------------------------
-WITH ranked AS (
-    SELECT
-        s.id as submission_id,
-        s.leaderboard_id,
-        l.name as problem_name,
-        s.user_id,
-        u.user_name,
-        s.code_id,
-        s.file_name,
-        s.submission_time,
-        s.status,
-        r.score,
-        r.passed,
-        r.mode,
-        r.runner,
-        COALESCE(c.old_code, convert_from(c.code, 'UTF8')) as code,
-        ROW_NUMBER() OVER (
-            PARTITION BY s.leaderboard_id, s.user_id, s.code_id
-            ORDER BY r.score ASC NULLS LAST
-        ) as rn
-    FROM leaderboard.submission s
-    JOIN leaderboard.leaderboard l ON s.leaderboard_id = l.id
-    LEFT JOIN leaderboard.user_info u ON s.user_id = u.id
-    LEFT JOIN leaderboard.runs r ON s.id = r.submission_id AND r.mode = 'leaderboard'
-    LEFT JOIN leaderboard.code_files c ON s.code_id = c.id
-    WHERE s.leaderboard_id IN (595, 597, 598)  -- Replace with problem IDs
-)
-SELECT
-    submission_id, leaderboard_id, problem_name, user_id, user_name,
-    code_id, file_name, submission_time, status, score, passed, mode, runner, code
-FROM ranked
-WHERE rn = 1
-ORDER BY problem_name, score ASC NULLS LAST;
---------------------------------------------------------------------------------
--- CHECK RUN MODES AND SCORES
---------------------------------------------------------------------------------
-SELECT
-    r.mode,
-    COUNT(*) as cnt,
-    COUNT(r.score) as has_score,
-    MIN(r.score) as min_score,
-    MAX(r.score) as max_score
-FROM leaderboard.runs r
-JOIN leaderboard.submission s ON r.submission_id = s.id
-WHERE s.leaderboard_id IN (595, 597, 598)
-GROUP BY r.mode
-ORDER BY cnt DESC;
---------------------------------------------------------------------------------
--- GET TOP N SUBMISSIONS FOR A PROBLEM
---------------------------------------------------------------------------------
-SELECT
-    u.user_name,
-    r.score,
-    s.submission_time
-FROM leaderboard.submission s
-JOIN leaderboard.runs r ON s.id = r.submission_id AND r.mode = 'leaderboard'
-LEFT JOIN leaderboard.user_info u ON s.user_id = u.id
-WHERE s.leaderboard_id = 595  -- Replace with problem ID
-  AND r.passed = true
-  AND r.score IS NOT NULL
-ORDER BY r.score ASC
-LIMIT 20;
---------------------------------------------------------------------------------
--- GET USER'S SUBMISSIONS OVER TIME (progression)
---------------------------------------------------------------------------------
-SELECT
-    s.submission_time,
-    r.score,
-    r.passed
-FROM leaderboard.submission s
-JOIN leaderboard.runs r ON s.id = r.submission_id AND r.mode = 'leaderboard'
-JOIN leaderboard.user_info u ON s.user_id = u.id
-WHERE u.user_name = 'gau.nernst'  -- Replace with username
-  AND s.leaderboard_id = 595  -- Replace with problem ID
-ORDER BY s.submission_time ASC;
---------------------------------------------------------------------------------
--- GET CODE FOR A SPECIFIC SUBMISSION
---------------------------------------------------------------------------------
-SELECT
-    COALESCE(c.old_code, convert_from(c.code, 'UTF8')) as code
-FROM leaderboard.code_files c
-WHERE c.id = 79741;  -- Replace with code_id

scripts/nvfp4/analyze_submissions.py DELETED Viewed

@@ -1,168 +0,0 @@
-#!/usr/bin/env python3
-"""
-Helper functions for analyzing kernelbot submissions.
-Usage:
-    from analyze_submissions import load_submissions, author_progression, top_contestants
-"""
-import pandas as pd
-from pathlib import Path
-def format_score(score, unit='us'):
-    """
-    Format score with appropriate units.
-    Args:
-        score: Score in seconds
-        unit: 'us' for microseconds, 'ms' for milliseconds, 'auto' for automatic
-    Returns:
-        Formatted string with units
-    """
-    if pd.isna(score):
-        return 'N/A'
-    if unit == 'auto':
-        if score < 0.001:  # Less than 1ms, show in microseconds
-            return f"{score * 1_000_000:.2f} µs"
-        elif score < 1:  # Less than 1s, show in milliseconds
-            return f"{score * 1_000:.3f} ms"
-        else:
-            return f"{score:.4f} s"
-    elif unit == 'us':
-        return f"{score * 1_000_000:.2f} µs"
-    elif unit == 'ms':
-        return f"{score * 1_000:.3f} ms"
-    else:
-        return f"{score:.6f} s"
-def load_submissions(parquet_path: str = None) -> pd.DataFrame:
-    """Load deduplicated submissions from parquet file."""
-    if parquet_path is None:
-        parquet_path = Path(__file__).parent.parent.parent / "nvidia_nvfp4_submissions.parquet"
-    return pd.read_parquet(parquet_path)
-def author_progression(df: pd.DataFrame, user_id: str = None, user_name: str = None,
-                       problem_name: str = None) -> pd.DataFrame:
-    """
-    Get submissions from an author sorted by time to see their progression.
-    Args:
-        df: DataFrame of submissions
-        user_id: Filter by user ID (Discord ID)
-        user_name: Filter by username (partial match, case-insensitive)
-        problem_name: Filter by problem name
-    Returns:
-        DataFrame sorted by submission_time showing the author's journey
-    """
-    result = df.copy()
-    if user_id:
-        result = result[result['user_id'] == user_id]
-    if user_name:
-        result = result[result['user_name'].str.contains(user_name, case=False, na=False)]
-    if problem_name:
-        result = result[result['problem_name'] == problem_name]
-    return result.sort_values('submission_time')
-def top_contestants(df: pd.DataFrame, problem_name: str = None, n: int = 20,
-                    passing_only: bool = True) -> pd.DataFrame:
-    """
-    Get top contestants sorted by their best score (fastest time).
-    Args:
-        df: DataFrame of submissions
-        problem_name: Filter by problem name (required for meaningful results)
-        n: Number of top contestants to return
-        passing_only: Only include passing submissions
-    Returns:
-        DataFrame with top contestants and their best scores
-    """
-    result = df.copy()
-    if problem_name:
-        result = result[result['problem_name'] == problem_name]
-    if passing_only:
-        result = result[result['passed'] == True]
-    # Filter out rows with NA scores
-    result = result.dropna(subset=['score'])
-    if result.empty:
-        return pd.DataFrame(columns=['user_name', 'user_id', 'score', 'submission_time', 'problem_name'])
-    # Get best score per user
-    best_scores = result.loc[result.groupby('user_id')['score'].idxmin()]
-    return best_scores.sort_values('score').head(n)[
-        ['user_name', 'user_id', 'score', 'submission_time', 'problem_name']
-    ]
-def leaderboard_summary(df: pd.DataFrame, score_unit='us') -> pd.DataFrame:
-    """
-    Get summary statistics for each problem.
-    Args:
-        df: DataFrame of submissions
-        score_unit: 'us' for microseconds, 'ms' for milliseconds, 's' for seconds
-    Returns:
-        DataFrame with submission counts, unique users, score ranges
-    """
-    summary = df.groupby('problem_name').agg({
-        'submission_id': 'count',
-        'user_id': 'nunique',
-        'score': ['min', 'median', 'max'],
-        'passed': 'sum'
-    })
-    summary.columns = ['submissions', 'unique_users', 'best_score', 'median_score',
-                       'worst_score', 'passing_count']
-    # Convert scores to specified unit
-    if score_unit == 'us':
-        multiplier = 1_000_000
-        summary['best_score'] = (summary['best_score'] * multiplier).round(2)
-        summary['median_score'] = (summary['median_score'] * multiplier).round(2)
-        summary['worst_score'] = (summary['worst_score'] * multiplier).round(2)
-    elif score_unit == 'ms':
-        multiplier = 1_000
-        summary['best_score'] = (summary['best_score'] * multiplier).round(3)
-        summary['median_score'] = (summary['median_score'] * multiplier).round(3)
-        summary['worst_score'] = (summary['worst_score'] * multiplier).round(3)
-    return summary
-def user_stats(df: pd.DataFrame, user_id: str = None, user_name: str = None) -> pd.DataFrame:
-    """
-    Get statistics for a specific user across all problems.
-    """
-    result = df.copy()
-    if user_id:
-        result = result[result['user_id'] == user_id]
-    elif user_name:
-        result = result[result['user_name'].str.contains(user_name, case=False, na=False)]
-    return result.groupby('problem_name').agg({
-        'submission_id': 'count',
-        'score': 'min',
-        'passed': 'sum'
-    }).rename(columns={
-        'submission_id': 'num_submissions',
-        'score': 'best_score',
-        'passed': 'passing_count'
-    })

scripts/nvfp4/get_fastest_submission.py DELETED Viewed

@@ -1,20 +0,0 @@
-#!/usr/bin/env python3
-"""Print gau.nernst's fastest submission code to stdout."""
-import pandas as pd
-from pathlib import Path
-df = pd.read_parquet(Path(__file__).parent.parent.parent / 'nvidia_nvfp4_submissions.parquet')
-# Get fastest submission across all problems
-best = df[df['user_name'] == 'gau.nernst'].sort_values('score').head(1)
-problem = best['problem_name'].values[0]
-score_us = best['score'].values[0] * 1_000_000
-print(f"User: gau.nernst")
-print(f"Problem: {problem}")
-print(f"Score: {score_us:.2f} µs")
-print(f"Submission ID: {best['submission_id'].values[0]}")
-print("\n=== CODE ===\n")
-print(best['code'].values[0])

scripts/nvfp4/query_submissions.py DELETED Viewed

@@ -1,57 +0,0 @@
-#!/usr/bin/env python3
-"""
-Query submissions by user/problem or by submission ID.
-Usage:
-    python query_submissions.py                     # Show all submission IDs for gau.nernst on gemv
-    python query_submissions.py --id 187476         # Show code for specific submission ID
-    python query_submissions.py --user gau.nernst --problem nvfp4_gemm
-"""
-import argparse
-import pandas as pd
-from pathlib import Path
-df = pd.read_parquet(Path(__file__).parent.parent.parent / 'nvidia_nvfp4_submissions.parquet')
-parser = argparse.ArgumentParser()
-parser.add_argument('--id', type=int, help='Submission ID to query')
-parser.add_argument('--user', default='gau.nernst', help='Username to filter')
-parser.add_argument('--problem', default='nvfp4_gemv', help='Problem name to filter')
-args = parser.parse_args()
-if args.id:
-    # Query specific submission
-    sub = df[df['submission_id'] == args.id]
-    if sub.empty:
-        print(f"Submission {args.id} not found")
-    else:
-        row = sub.iloc[0]
-        score_us = row['score'] * 1_000_000 if pd.notna(row['score']) else 'N/A'
-        print(f"ID: {row['submission_id']}")
-        print(f"User: {row['user_name']}")
-        print(f"Problem: {row['problem_name']}")
-        print(f"Score: {score_us:.2f} µs" if isinstance(score_us, float) else f"Score: {score_us}")
-        print(f"\n=== CODE ===\n")
-        print(row['code'])
-else:
-    # List all submission IDs for user/problem
-    subs = df[(df['user_name'] == args.user) & (df['problem_name'] == args.problem)]
-    subs = subs.sort_values('score')
-    ids = subs['submission_id'].tolist()
-    scores = [(row['submission_id'], row['score'] * 1_000_000 if pd.notna(row['score']) else None)
-              for _, row in subs.iterrows()]
-    print(f"User: {args.user} | Problem: {args.problem} | Count: {len(ids)}")
-    print(f"\nSubmission IDs (sorted by score, fastest first):")
-    print(ids)
-    # Get fastest/slowest with valid scores
-    valid_scores = [(sid, sc) for sid, sc in scores if sc is not None]
-    if valid_scores:
-        print(f"\nFastest: {valid_scores[0][0]} ({valid_scores[0][1]:.2f} µs)")
-        print(f"Slowest: {valid_scores[-1][0]} ({valid_scores[-1][1]:.2f} µs)")
-        print(f"\nQuery a specific submission: python query_submissions.py --id {valid_scores[0][0]}")
-    else:
-        print("\nNo submissions with scores found")