Loading...
Loading
Overview
Registration Activity
Neuron registration trends
This Interval
0
— burn · — PoW
Target / Interval
Loading
Neuron registration trends
Modern machine learning research faces two structural challenges: algorithm development is centralized in well-funded labs, and research reproducibility requires expensive redundant infrastructure. Individual researchers cannot cost-effectively run multiple independent evaluation passes on proprietary algorithms, and novel approaches often languish without sufficient computational resources to validate their merit. Distributed research networks with cryptoeconomic incentives can decentralize algorithm discovery by enabling researchers to contribute compute and expertise across a shared evaluation framework.
BitSota solves this by operating a decentralized research subnet where participants compete to evolve and validate machine learning algorithms. Instead of one lab doing all research, many miners can propose algorithms and compete on standardized benchmarks. Validators independently replay submissions in isolated environments and vote on merit through smart contracts. Contributions are rewarded automatically based on validator consensus and the backend reward snapshot.
Built on Bittensor's SN94, BitSota provides the coordination layer, distributed compute network, and incentive structure that makes reproducible decentralized research economically viable. Miners scale horizontally, validators operate with Docker/CUDA sandbox isolation, and rewards flow through Merkle claim contracts.
Use cases were auto-generated from the GitHub repository and may not reflect the latest changes.
BitSota is a decentralized research subnet on Bittensor that evolves machine learning algorithms through competitive optimization using genetic programming. Miners develop ML algorithms on fixed and research benchmarks while validators replay submissions in Docker/CUDA sandbox environments and apply backend-directed weights.
BitSota uses a multi-component distributed architecture. Miners submit solutions through a sidecar API to either a relay service (direct mode) or Pool API (pool mode). The autoresearch backend coordinates research tasks and stores submissions.
Validators obtain replay specifications from the backend, execute submissions in isolated Docker/CUDA containers, and report observed metrics back to the backend. The backend publishes reward snapshots containing validator weights. Backend weight setters fetch these snapshots and submit Bittensor set_weights transactions.
Pool publishes Merkle roots for claim distribution. Miners claim rewards from the Merkle contract.
Miners earn by submitting algorithms that beat the current SOTA bar. Validators replay submissions with private heldout data, posting observed metrics to the backend. The autoresearch backend computes reward_policy.validator_weights based on submission quality.
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.
Validators run two services: (1) research_validator_runner for Docker replay validation, (2) backend_weight_setter to apply backend-directed weights to the chain. Pool miners contribute evaluation and evolution work; consensus is strict k-of-n agreement with tolerance. Rewards convert to alpha stake through Merkle claim contracts.
The sections above were auto-generated from the GitHub repository and may not reflect the latest changes. View repository
pending...
pending...
FAQs were auto-generated from the GitHub repository and may not reflect the latest changes.
Holder & total-staked metrics as of 2h ago (hourly snapshot)
Direct mining requires more compute resources; pool mining can run on lower-spec hardware. Genetic programming and evolution engines benefit from additional CPU cores and RAM.
Validators must run Docker with CUDA GPU access. Tested on g5.2xlarge EC2 (A10G, 24GB VRAM, 8 vCPU, 32GB RAM). Keep at least 50GB free for Docker images, replay workspaces, and artifacts.
Clone the main repository
git clone https://github.com/AlveusLabs/SN94-BitSota.git && cd SN94-BitSota
Set up Python virtual environment and install dependencies
python3 -m venv .venv && source .venv/bin/activate && pip install -U pip && pip install -r requirements.txt && pip install -e .
Create miner configuration file from example
cp miner_config.yaml.example miner_config.yaml
Run CLI miner in direct or pool mode based on configuration
python neurons/miner.py --config miner_config.yaml
Install Ubuntu packages and Docker
sudo apt update && sudo apt install -y git curl ca-certificates python3.11 python3.11-venv python3.11-dev python3-pip build-essential docker.io
Configure Docker and create validator directories
sudo systemctl enable --now docker && sudo usermod -aG docker $USER && sudo install -d -m 0750 -o $USER -g $USER /opt/bitsota && sudo install -d -m 0700 -o $USER -g $USER /srv/bitsota/public-validator-workspaces
Clone and install SN94-BitSota validator code
git clone --branch main https://github.com/AlveusLabs/SN94-BitSota.git /opt/bitsota/SN94-BitSota && cd /opt/bitsota/SN94-BitSota && python3.11 -m venv .venv && source .venv/bin/activate && pip install -U pip && pip install -r requirements.txt && pip install -e .
Create validator wallet and register on SN94
btcli wallet new_coldkey --wallet.name validator_wallet && btcli wallet new_hotkey --wallet.name validator_wallet --wallet.hotkey validator_hotkey && btcli subnet register --netuid 94 --wallet.name validator_wallet --wallet.hotkey validator_hotkey --network finney
Create replay validator configuration from example
cp research_validator_config.yaml.example research_validator_config.yaml
Test replay validator with single cycle
python -m validator.research_validator_runner --config research_validator_config.yaml --once --no-dry-run
Create backend weight setter configuration
cat > validator_config.weights.yaml <<'EOF' netuid: 94 wallet_name: "validator_wallet" wallet_hotkey: "validator_hotkey" path: "~/.bittensor/wallets/" network: "finney" subtensor_chain_endpoint: "wss://entrypoint-finney.opentensor.ai:443" epoch_length: 100 weights: wait_for_inclusion: true wait_for_finalization: false EOF
Test backend weight setter in dry-run mode
python -m validator.backend_weight_setter --config validator_config.weights.yaml --dry-run --ignore-rate-limit
Install systemd services for replay validator and backend weight setter
sudo tee /etc/systemd/system/bitsota-replay-validator.service && sudo tee /etc/systemd/system/bitsota-backend-weights.service && sudo systemctl daemon-reload && sudo systemctl enable --now bitsota-replay-validator.service && sudo systemctl enable --now bitsota-backend-weights.service
