Datasets:

GPUMODE
/

kernelbot-data

@@ -1,237 +0,0 @@
-June 9 Researcher Reciprocity License
-Version 1.0
-dated June 9, 2026
-This is a license (the "License") between you ("You") and GPU Mode and the
-KernelBot dataset contributors ("Licensor"). This License adapts the Open
-Responsible AI License Data ("Open RAIL-D") pattern for a dataset artifact and
-adds the Researcher Reciprocity use restriction in Attachment A. It is intended
-to have an open and permissive character while preserving reciprocal research
-access when the Dataset is used to train or improve AI systems.
-If you train on it, you let us generate.
-Section I: Preamble
-KernelBot is a competition platform for writing heterogeneous GPU code. The
-Dataset contains submissions, metadata, benchmark results, and related materials
-from KernelBot competitions.
-Licensor wishes to promote collaboration, open research, education,
-benchmarking, and broad reuse of the Dataset. Licensor also wishes to avoid a
-one-way bargain in which researchers and contributors publish ideas and code
-that are used to improve AI systems, while the providers of those AI systems
-then prohibit those same researchers from generating outputs, evaluating the
-systems, benchmarking them, publishing research, or exploring their own ideas.
-This License therefore grants broad rights to use the Dataset, subject to
-attribution and the use-based restriction in Attachment A.
-Section II: Definitions
-1. "License" means these terms and conditions for use, reproduction, and
-Distribution.
-2. "Dataset" means the files, records, metadata, documentation, and other
-materials distributed with this License.
-3. "Output" means the results of operating a model, service, application, or
-other system.
-4. "Model" means any machine-learning or artificial-intelligence based
-assemblies, including model weights, checkpoints, parameters, optimizer states,
-adapters, embedding systems, agents, APIs, hosted services, or other systems
-that are trained, tuned, evaluated, benchmarked, or otherwise used in connection
-with the Dataset.
-5. "Derivatives of the Dataset" means all modifications, transformations,
-annotations, translations, extracts, subsets, compilations, arrangements, or
-other works based on the Dataset.
-6. "Derivatives of a Model" means all modifications to a Model, works based on
-a Model, or any other model that is created or initialized by transfer of
-patterns of weights, parameters, activations, embeddings, outputs, or other
-representations of the Model, including distillation methods and methods based
-on synthetic data generated by the Model.
-7. "Training Use" means using the Dataset, in whole or in part, to train,
-pretrain, fine-tune, post-train, align, distill, evaluate for training,
-benchmark for training, generate synthetic data for training, construct
-embeddings for training, rank or filter examples for training, or otherwise
-improve the weights, behavior, capabilities, or performance of a Model or
-Derivatives of a Model.
-8. "Covered Model" means any Model or Derivatives of a Model that is trained,
-fine-tuned, distilled, aligned, evaluated for training, benchmarked for
-training, or otherwise improved through Training Use of the Dataset.
-9. "Distribution" means any transmission, reproduction, publication, hosting,
-or other sharing of the Dataset, Derivatives of the Dataset, a Covered Model, or
-Derivatives of a Covered Model to a third party, including making any of them
-available by electronic or remote means, such as API-based or web access.
-10. "Licensor" means GPU Mode, the dataset maintainers, and any contributor who
-has authority to license their contribution under these terms.
-11. "You" or "Your" means an individual or legal entity exercising permissions
-granted by this License or making use of the Dataset for any purpose.
-12. "Third Parties" means individuals or legal entities that are not under
-common control with Licensor or You.
-13. "Authorized Researchers" means GPU Mode, the dataset maintainers, dataset
-contributors, and any researchers or organizations that GPU Mode designates in
-writing for purposes of generating outputs from, evaluating, benchmarking,
-auditing, criticizing, or publishing research about a Covered Model.
-14. "Ordinary Users" means the general class of users to whom You make a
-Covered Model available, including through a public product, commercial product,
-research release, API, hosted service, preview, beta, or gated access program.
-Section III: Intellectual Property Rights
-2. Grant of Copyright License. Subject to the terms and conditions of this
-License, each Licensor grants You a worldwide, non-exclusive, no-charge,
-royalty-free copyright license to reproduce, prepare derivative works of,
-publicly display, publicly perform, sublicense, and distribute the Dataset and
-Derivatives of the Dataset.
-3. No Patent License. This License does not grant any patent license.
-Section IV: Conditions of Usage, Distribution, and Redistribution
-4. Distribution and Redistribution. You may reproduce and distribute copies of
-the Dataset or Derivatives of the Dataset in any medium, with or without
-modifications, provided that You meet the following conditions:
-4.1. You must give Third Party recipients of the Dataset or Derivatives of the
-Dataset a copy of this License or a clear link to it.
-4.2. You must retain reasonable copyright, license, and attribution notices,
-excluding notices that do not pertain to any part of the Dataset or Derivatives
-of the Dataset.
-4.3. You must give reasonable attribution to GPU Mode and the KernelBot dataset.
-Reasonable attribution includes, where practical, the dataset name, a link to
-the dataset source, and any citation requested in the Dataset documentation.
-4.4. You must cause any modified files, datasets, or documentation that You
-Distribute to carry prominent notices stating that You changed them.
-4.5. You may add Your own copyright statement to Your modifications and may
-provide additional or different license terms for Your independent additions,
-annotations, analyses, software, models, outputs, or other works, provided that
-Your use, reproduction, and Distribution of the Dataset otherwise complies with
-this License.
-5. Use-Based Restrictions. The restriction set forth in Attachment A is a
-use-based restriction. You may not use the Dataset, Derivatives of the Dataset,
-Covered Models, or Derivatives of Covered Models for the restricted use
-specified in Attachment A.
-For Training Use, the use-based restriction in Attachment A must be included as
-an enforceable provision in any legal agreement, terms of use, acceptable use
-policy, license, or other terms governing the use or Distribution of a Covered
-Model or Derivatives of a Covered Model. You must give notice to subsequent
-users that the Covered Model or Derivatives of the Covered Model are subject to
-Attachment A.
-6. Outputs. Except as stated in this License, Licensor claims no rights in the
-Output You generate using a Covered Model. You are accountable for the Output
-You generate and its subsequent uses. No use of the Output may contravene this
-License.
-Section V: Other Provisions
-7. No Endorsement. Nothing in this License permits You to use Licensor's names,
-logos, trademarks, or service marks to imply endorsement, sponsorship, or
-approval.
-8. Third-Party Rights. The Dataset may include material submitted by third
-parties. This License applies only to rights that Licensor has authority to
-license. You are responsible for complying with any third-party rights, privacy
-obligations, laws, or regulations that apply to Your use.
-9. Disclaimer of Warranty. Unless required by applicable law or agreed to in
-writing, Licensor provides the Dataset on an "AS IS" BASIS, WITHOUT WARRANTIES
-OR CONDITIONS OF ANY KIND, either express or implied, including warranties or
-conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, FITNESS FOR A PARTICULAR
-PURPOSE, ACCURACY, AVAILABILITY, OR ABSENCE OF DEFECTS. You are solely
-responsible for determining the appropriateness of using or redistributing the
-Dataset and assume any risks associated with Your exercise of permissions under
-this License.
-10. Limitation of Liability. To the maximum extent permitted by law, in no event
-and under no legal theory, whether in tort, contract, or otherwise, unless
-required by applicable law or agreed to in writing, shall any Licensor or
-contributor be liable to You for damages, including direct, indirect, special,
-incidental, consequential, exemplary, or punitive damages arising as a result of
-this License or out of the use or inability to use the Dataset, even if such
-Licensor or contributor has been advised of the possibility of such damages.
-11. Accepting Warranty or Additional Liability. While redistributing the Dataset
-or Derivatives of the Dataset, You may choose to offer, and charge a fee for,
-acceptance of support, warranty, indemnity, or other liability obligations or
-rights consistent with this License. However, in accepting such obligations, You
-may act only on Your own behalf and on Your sole responsibility, not on behalf
-of any Licensor or contributor, and only if You agree to indemnify, defend, and
-hold each Licensor and contributor harmless for any liability incurred by, or
-claims asserted against, such Licensor or contributor by reason of Your
-accepting any such warranty or additional liability.
-12. Termination. If You violate this License, Your rights under it terminate
-automatically. For violations other than violations of Attachment A, Your rights
-are reinstated if You cure the violation within 30 days after discovering it or
-receiving written notice from Licensor. For violations of Attachment A involving
-a Covered Model, Your Training Use rights terminate automatically as to the
-affected Covered Model and may be reinstated only if Licensor provides written
-reinstatement or waiver.
-13. Severability. If any provision of this License is held invalid, illegal, or
-unenforceable, the remaining provisions remain valid as if the provision had not
-been set forth. The unenforceable provision will be interpreted or reformed only
-to the minimum extent necessary to make it enforceable while preserving its
-purpose.
-14. Additional Permission. Licensor may grant additional permissions,
-exceptions, waivers, commercial terms, or private licenses in writing. Those
-permissions apply only to the recipient and scope stated in the written grant.
-End of Terms and Conditions
-Attachment A
-Use Restriction: Researcher Reciprocity for Training Use
-You agree not to use the Dataset or Derivatives of the Dataset for Training Use
-if You make the resulting Covered Model or Derivatives of the Covered Model
-available under terms, policies, technical measures, access rules, account
-restrictions, acceptable-use rules, or other conditions that prohibit, penalize,
-or materially burden Authorized Researchers from:
-1. generating outputs from the Covered Model;
-2. evaluating, auditing, red-teaming, or benchmarking the Covered Model;
-3. comparing the Covered Model to other systems;
-4. publishing research, criticism, measurements, benchmark results, or analysis
-concerning the Covered Model; or
-5. using the Covered Model to explore, test, or develop their own research
-ideas.
-This access must be available on materially equal terms to those offered to
-Ordinary Users of the Covered Model, subject only to neutral limits that apply
-equally to Ordinary Users, such as generally applicable rate limits, payment
-terms, safety rules, security rules, and laws.
-Any terms, policies, technical measures, access rules, account restrictions,
-acceptable-use rules, or other conditions that conflict with this Attachment A
-make the Covered Model ineligible for the Training Use grant unless Licensor has
-waived the conflict in writing.
-You may not suspend, ban, throttle, sue, threaten, or otherwise retaliate
-against Authorized Researchers solely because they engage in the activities
-listed in this Attachment A, provided that their activity complies with
-generally applicable law and neutral safety or security rules that are also
-applied to Ordinary Users.

README.md CHANGED Viewed

@@ -1,126 +1,27 @@
 ---
 configs:
-- config_name: amd_submissions
   data_files: "submissions.parquet"
-- config_name: amd_successful_submissions
   data_files: "successful_submissions.parquet"
-- config_name: amd_1_1m_competition
-  data_files: "amd_1_1m_competition_submissions.parquet"
-- config_name: helion_b200_nebius
-  data_files: "helion_b200_nebius_submissions.parquet"
-- config_name: trimul_submissions
-  data_files: "trimul_submissions.parquet"
-- config_name: nvidia_nvfp4_submissions
-  data_files: "nvidia_nvfp4_submissions.parquet"
-- config_name: pmpp_v2_submissions
-  data_files: "pmpp_v2_submissions.parquet"
 - config_name: leaderboards
   data_files: "leaderboards.parquet"
 tags:
 - code
-license: other
 ---
-# 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, mxfp4-mm, moe-mxfp4, mixed-mla
-### AMD 1.1M Competition
-| File | Size | Description |
-|------|------|-------------|
-| `amd_1_1m_competition_submissions.parquet` | ~699 MB | Deduplicated submissions with code for `amd-mxfp4-mm` (763), `amd-moe-mxfp4` (764), and `amd-mixed-mla` (765) |
-### Trimul
-| File | Size | Description |
-|------|------|-------------|
-| `trimul_submissions.parquet` | ~120 MB | Deduplicated submissions with code for `trimul` (leaderboard 496) |
-`trimul` is a separate mixed-GPU problem and is not grouped with the AMD competition exports.
-### Helion B200_Nebius
-| File | Size | Description |
-|------|------|-------------|
-| `helion_b200_nebius_submissions.parquet` | ~4 MB | Deduplicated submissions with code for `causal_conv1d` (766), `fp8_quant` (767), `gated_deltanet_chunk_fwd_h` (768), `gated_deltanet_chunk_fwd_o` (769), and `gated_deltanet_recompute_w_u` (770) |
-**Measurement note:** these problems were run on `B200_Nebius`, and the measurements for this problem set are brittle. Treat leaderboard scores from this export with extra caution.
-### 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), group_gemm (730)
-**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.**
-### PMPP v2 Submissions
-| File | Size | Description |
-|------|------|-------------|
-| `pmpp_v2_submissions.parquet` | ~28 MB | All PMPP v2 submissions with full code content |
-**PMPP v2 Problems:** conv2d_v2 (537), grayscale_v2 (538), histogram_v2 (539), matmul_v2 (540), prefixsum_v2 (541), sort_v2 (542), vectoradd_v2 (543), vectorsum_v2 (544)
-## 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 [June 9 Researcher Reciprocity License](LICENSE).
-You are free to use, share, analyze, transform, and redistribute the material for research, education, benchmarking, publication, commercial analysis, and other lawful purposes, provided you give appropriate credit.
-This license adapts the Open RAIL-D structure and adds one specific use restriction: training, fine-tuning, distillation, synthetic-data generation for training, embedding for training, or otherwise using this dataset to improve an AI model or AI service requires Researcher Reciprocity.
-> If you train on it, you let us generate.
-Covered AI model and service providers may not use this dataset while imposing terms that prevent GPU Mode, dataset contributors, or authorized researchers from generating outputs, evaluating models, benchmarking, publishing research, or exploring their own research ideas on materially equal terms to ordinary users.
-**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},

amd_1_1m_competition_submissions.parquet DELETED Viewed

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

docs.md DELETED Viewed

@@ -1,191 +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
-### 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
-- **763**: amd-mxfp4-mm
-- **764**: amd-moe-mxfp4
-- **765**: amd-mixed-mla
-### Other Completed Public Problems
-- **496**: trimul
-### PMPP v2 Problems
-- **537**: conv2d_v2
-- **538**: grayscale_v2
-- **539**: histogram_v2
-- **540**: matmul_v2
-- **541**: prefixsum_v2
-- **542**: sort_v2
-- **543**: vectoradd_v2
-- **544**: vectorsum_v2
-### Released Helion / B200_Nebius Problems
-- **766**: causal_conv1d
-- **767**: fp8_quant
-- **768**: gated_deltanet_chunk_fwd_h
-- **769**: gated_deltanet_chunk_fwd_o
-- **770**: gated_deltanet_recompute_w_u
-## Additional Export Files
-- `amd_1_1m_competition_submissions.parquet`: deduplicated submissions with code for leaderboards 763, 764, and 765
-- `trimul_submissions.parquet`: deduplicated submissions with code for leaderboard 496
-- `helion_b200_nebius_submissions.parquet`: deduplicated submissions with code for leaderboards 766, 767, 768, 769, and 770
-- `pmpp_v2_submissions.parquet`: all submissions with code for leaderboards 537, 538, 539, 540, 541, 542, 543, and 544
-`trimul` is exported separately because it spans multiple GPU families and is not part of the AMD 1.1M competition set.
-The Helion export is released separately because it targets `B200_Nebius`; measurements for that problem set are brittle and should be interpreted cautiously.
-## 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

helion_b200_nebius_submissions.parquet DELETED Viewed

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

leaderboards.parquet CHANGED Viewed

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:95d9cc00565a3ba6aad7c95ed98743f571eeb53fc7d940ed7570be3947ebb673
-size 22104

 version https://git-lfs.github.com/spec/v1
+oid sha256:fa6456b3a46d2f4edcd6b507f1edd09b0a9ff86178219645b027463ed48768a6
+size 29735

nvidia_nvfp4_submissions.parquet DELETED Viewed

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

pmpp_v2_submissions.parquet DELETED Viewed

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

queries.sql DELETED Viewed

@@ -1,129 +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), 697 (modal_dual_gemm), 730 (group_gemm)
--- AMD: 398 (identity), 399 (fp8-mm), 430 (moe), 463 (mla-decode),
---      563 (all2all), 564 (gemm-rs), 565 (ag-gemm), 763 (mxfp4-mm),
---      764 (moe-mxfp4), 765 (mixed-mla)
--- Separate mixed-GPU export: 496 (trimul)
--- Released Helion/B200_Nebius export: 766 (causal_conv1d), 767 (fp8_quant),
---      768 (gated_deltanet_chunk_fwd_h), 769 (gated_deltanet_chunk_fwd_o),
---      770 (gated_deltanet_recompute_w_u)
---------------------------------------------------------------------------------
--- 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")

trimul_submissions.parquet DELETED Viewed

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