Loading...
Loading
Development Activity
RendixNetwork/leomaPython
241 contributors48 commits/30dLast commit 48d ago
LicenseCI/CDDockerRequirements
Top Contributors
Loading
Neuron registration trends
Video generation models lack a standardized, reproducible evaluation framework. Researchers and practitioners need objective metrics to compare text-to-video and image-to-video generators, but evaluation is fragmented across proprietary metrics, manual review, and non-deterministic setups that produce inconsistent results across validators or raters.
Leoma solves this by creating a decentralized, incentivized network where independent validators run identical duels on a pinned corpus of held-out video clips. Each duel is deterministic—seeded by the block hash to prevent overfitting—and scores both a challenger model and the reigning champion against ground-truth video continuations using reference-based metrics (LPIPS, MSE, SSIM). The challenger is crowned only if it wins with statistical confidence, ensuring fair, reproducible rankings.
On Bittensor, Leoma implements this as a "king of the hill" competition. Miners fine-tune a pinned Wan2.2 image-to-video base architecture, upload weights to Hippius Hub (a content-addressed registry), and commit a cryptographic reveal on-chain. Validators download the weights, pre-screen for architecture compliance, dispatch duels to GPU eval servers, and crown winners. All duel parameters—corpus manifest, resolution, metric, confidence threshold—are pinned in chain.toml and hashed into a consensus digest that every validator verifies, eliminating silent disagreement.
Use cases were auto-generated from the GitHub repository and may not reflect the latest changes.
Leoma is an AI video subnet on Bittensor implementing a 'king of the hill' competition where miners fine-tune a pinned Image/Text-to-Video (I2V/TI2V) base model and submit challenger weights to Hippius Hub. Validators download submitted models and run deterministic, reference-based duels against the reigning king using held-out video clips, scoring challengers against ground-truth continuations with LPIPS distance metrics. The challenger is crowned if it wins with statistical confidence, and emission is split equally across the king and recent prior kings.
Leoma's architecture decouples weight submission, validation, and inference. Miners upload fine-tuned Wan2.2 model weights (as .safetensors) to Hippius Hub and commit an immutable repo@digest reveal on-chain (never touching inference). Validators independently scan the chain, discover reveals, and queue challengers.
For each challenger, the validator dispatches a duel request to its dedicated GPU eval server, which downloads king and challenger weights by digest, pre-screens for architecture/freeze compliance, then runs a deterministic duel on held-out clips seeded by the current block hash. The eval server scores both models and returns a verdict. The validator crowns the winner if confident enough, slides the deposed king onto a bounded king chain, and sets equal weights across all active kings.
All duel parameters (corpus, prompts, resolution, metric, threshold) are pinned in chain.toml, hashed into a consensus_digest, and verified by every eval box; mismatches are refused at dispatch time. King state is persisted durably to the validator's S3-compatible state bucket.
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.
For each challenger submission, the validator dispatches a duel to the eval server. Both king and challenger generate a 5-frame continuation from the first frame of a held-out test clip using the same block-hash-seeded random seed. Each generation is scored against the ground-truth continuation using LPIPS (default) or MSE/SSIM reference distance (lower is better).
The challenger is crowned only if the per-clip advantage (king_distance - challenger_distance) is statistically confident: the lower confidence bound of the bootstrapped advantage must exceed delta_threshold. The freeze cheat gate rejects models that emit the conditioning frame repeated. Deposed kings slide onto a bounded king chain; equal weights are set across all registered kings in the chain.
The sections above were auto-generated from the GitHub repository and may not reflect the latest changes.
FAQs were auto-generated from the GitHub repository and may not reflect the latest changes.
Holder & total-staked metrics as of 1h ago (hourly snapshot)
Miners do not host inference; they only upload fine-tuned weights to Hippius Hub. Training infrastructure (GPU) is required separately but not specified in documentation.
Validator itself runs on CPU; requires network access to a separate GPU eval server. State bucket (Hippius/S3-compatible) for durable king state required.
Install Leoma package and dependencies
pip install -e .
Upload fine-tuned model weights to Hippius Hub. Repository name must start with 'leoma' and end with your miner hotkey (SS58). Capture the returned immutable repo@sha256:digest reference.
leoma miner push --model-dir ./out --repo <user-or-project>/leoma-<model-name>-<your-hotkey-ss58> --revision submission-001
Commit the immutable repo+digest reveal on-chain. Only repo, digest, and hotkey are written; validators discover and duel your model.
leoma miner commit --repo <user-or-project>/leoma-<model-name>-<hotkey> --digest sha256:<...> --coldkey <wallet-name> --hotkey <hotkey-name>
Install Leoma package (Python 3.12+)
pip install -e .
Copy validator environment template and fill in wallet names, EVAL_SERVER_URL(s), Hippius credentials, state bucket, and dashboard bucket
cp env.validator.example .env
Verify all prerequisites before launch: seed/corpus pinned, wallet registered, hotkey permitted, all eval servers reachable and match consensus/runtime digests
leoma preflight
Start validator: scan reveals -> dispatch duels to eval server -> crown winners -> set weights
leoma serve
