Add NVIDIA NVFP4 submissions data

- Add nvidia_nvfp4_submissions.parquet (~1.4GB) with 197,594 deduplicated submissions
- Includes nvfp4_gemv (35,559), nvfp4_gemm (48,682), nvfp4_dual_gemm (113,353)
- All submissions include full code content
- Add docs.md with data processing documentation
- Add queries.sql with SQL queries for data extraction
- Add scripts/nvfp4/ with helper scripts for analysis
- Update README.md with NVIDIA data documentation

.gitignore

@@ -0,0 +1 @@
+__pycache__/

README.md

@@ -1,9 +1,11 @@
 ---
 configs:
-- config_name: submissions
+- config_name: amd_submissions
   data_files: "submissions.parquet"
-- config_name: successful_submissions
+- 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:
@@ -11,11 +13,62 @@ tags:
 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
+# KernelBot Competition Data
 
-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
+This dataset contains GPU kernel submissions from the KernelBot competition platform. Submissions are optimized GPU kernels written for specific hardware targets.
 
-We are planning on adding kernels optimized for NVFP4 on Blackwell next
+## 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 |
+
+**NVIDIA NVFP4 Problems:**
+| Problem | Submissions | Unique Users | Passing |
+|---------|-------------|--------------|---------|
+| nvfp4_gemv | 35,559 | 281 | 4,860 |
+| nvfp4_gemm | 48,682 | 160 | 26,123 |
+| nvfp4_dual_gemm | 113,353 | 160 | 73,802 |
+
+**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)
+
+## Citation
 
 If you use this dataset in your work, please cite:
 

docs.md

@@ -0,0 +1,158 @@
+# 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

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

queries.sql

@@ -0,0 +1,124 @@
+-- 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

@@ -0,0 +1,168 @@
+#!/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

@@ -0,0 +1,20 @@
+#!/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

@@ -0,0 +1,57 @@
+#!/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")