Loading
Loading
Incentivizing the improvement of the algorithms behind a pretraining run
Neuron registration trends
Language model training efficiency depends heavily on the optimizerโthe algorithm that updates model weights during training. Standard gradient descent and its variants leave performance on the table; researchers lack a coordinated, incentivized way to discover better update rules and validate them at meaningful scale. The barrier is high: training runs are expensive, results are hard to reproduce across institutions, and individual contributors cannot easily share discoveries or get rewarded for progress.
A distributed research network addresses this by creating a shared evaluation framework where contributors submit optimizer implementations and validators independently score them under identical conditions. Improvements are measured objectively, confirmed through re-runs to prevent luck-based results, and credited to their authors. This decouples algorithmic innovation from infrastructure ownership and creates economic incentive for continuous refinement.
Refinery implements this as a Bittensor subnet where miners submit Python optimizer code, validators train a standardized 360M-parameter model on FineWeb-Edu data with up to 20 hours on a B200 GPU, and measure validation loss improvements. Confirmed improvements that exceed an adaptive qualification threshold earn rewards proportional to their size. Results and source code become public research artifactsโnot proprietary.
Use cases were auto-generated from the GitHub repository and may not reflect the latest changes.
Refinery (Bittensor subnet 125) is an incentivized research network where miners submit optimizer algorithms for language model training. Validators independently evaluate submitted optimizers under a fixed compute budget (one B200 GPU, max 20 hours) on a standardized 360M-parameter Llama-style model using FineWeb-Edu data. Miners earn rewards based on verified improvements in validation loss, with a focus on discovering practical update rules that improve model learning efficiency.
The subnet aims to advance open-source AI by crowdsourcing algorithmic improvements through a global pool of researchers and AI agents.
Refinery operates as a distributed research pipeline: miners implement optimizer algorithms locally, test them, and submit source code with evaluation credentials to their registered hotkeys. Validators pull optimizer implementations, execute standardized training runs on B200 GPUs under fixed compute budgets (max 20 hours), score resulting checkpoints against validation loss metrics, and confirm improvements through independent re-runs. The round state machine (roundsm) orchestrates evaluation cycles, manages qualifying thresholds adaptively, and attributes confirmed improvements to miners.
Payment accounting tracks earned credits and distributes rewards based on improvement magnitude and recency. Verification and sandbox systems ensure source code authenticity and safe execution of untrusted optimizer submissions.
Incentivizing the improvement of the algorithms behind a pretraining run
This information was auto-extracted from the GitHub repository and may be incomplete or out of date. Always refer to the subnet's GitHub repository for the latest instructions.
Confirmed improvements receive credit proportional to their magnitude. The credit allocation determines how rewards are shared among miners in a round. Recent network progress (measured by accumulated improvements) determines the total miner emission paid versus burned.
There is no reward for merely submitting, staying online, or matching existing optimizers. The launch burn floor is 0% from day one, meaning payouts are not guaranteed and depend on network activity level.
The sections above were auto-generated from the GitHub repository and may not reflect the latest changes. View repository
FAQs were auto-generated from the GitHub repository and may not reflect the latest changes.
Holder & total-staked metrics as of 3h ago (hourly snapshot)
GPU not required to serve optimizer source code, but meaningful local training experiments require suitable compute for testing candidates before submission
Validators run evaluation jobs on B200 GPU with max 20-hour compute budget per run
Create a dedicated Python virtual environment
python3 -m venv .venv
Activate the virtual environment
. .venv/bin/activate
Install required dependencies including torch, transformers, and bittensor
python -m pip install -r requirements.txt
Verify installation and view available commands
python -m sn125 --help
Create an optimizer implementation following the miner template
Implement optimizer in Python using the supplied interface (see sn125/miner_template.py)
Test optimizer against matched controls on own research budget before submission
Run local experiments to test the candidate optimizer
Serve optimizer source from registered miner hotkey with adequate credits
Register miner hotkey and fund evaluation credits
Commit source code hash and be ready to reveal identical source when requested
Commit to source hash and prepare for validator requests
Create a dedicated Python virtual environment
python3 -m venv .venv
Activate the virtual environment
. .venv/bin/activate
Install required dependencies
python -m pip install -r requirements.txt
Obtain verified production configuration before deployment
Verify production identity, treasury address, fee, task/data pins and current frontier
Verify installation and view available commands
python -m sn125 --help