add new version

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,12 @@
+scores.json
+main.py
+test.py
+vali_runs.json
+venv/
+venv/*
+__pycache__/
+__pycache__/*
+.env
+wandb/
+wandb/*
+.oldgit/

README.md

@@ -0,0 +1,12 @@
+---
+title: Ai Detection Leaderboard
+emoji: 📈
+colorFrom: red
+colorTo: pink
+sdk: gradio
+sdk_version: 3.50.2
+app_file: app.py
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,493 @@
+import argparse
+import gradio as gr
+import bittensor as bt
+from typing import Dict, List, Any, Optional, Tuple
+from dataclasses import dataclass
+import wandb
+import math
+import os
+import datetime
+import time
+import json
+from dotenv import load_dotenv
+from huggingface_hub import HfApi
+from apscheduler.schedulers.background import BackgroundScheduler
+import pandas as pd 
+from tqdm import tqdm
+import numpy as np
+
+load_dotenv()
+
+FONT = (
+    """<link href="https://fonts.cdnfonts.com/css/jmh-typewriter" rel="stylesheet">"""
+)
+TITLE = """<h1 align="center" id="space-title" class="typewriter">Subnet 32 Leaderboard</h1>"""
+HEADER = """<h2 align="center" class="typewriter"><a href="https://github.com/It-s-AI/llm-detection" target="_blank">Subnet 32</a> is a <a href="https://bittensor.com/" target="_blank">Bittensor</a> subnet that incentivizes the development of distributed solutions aimed at identifying LLM-generated content. Reward calculation integrates F1 score, False Positive score, and Average Precision score to accurately evaluate model performance.</h3>"""
+EVALUATION_DETAILS = """<ul><li><b>UID:</b> the Bittensor UID of the miner</li><li><b>Rewards:</b> result number that is average of 3 metrics below.</li><li><b>F1 Score:</b> f-score metric</li><li><b>FP:</b> False Positive metric</li><li><b>AP:</b> average precision metric</li></ul><br/>More stats on <a href="https://x.taostats.io/subnet/32" target="_blank">taostats</a>."""
+EVALUATION_HEADER = """<h3 align="center">Shows the latest internal evaluation statistics as calculated by the "OpenTensor Foundation" validator</h3>"""
+VALIDATOR_WANDB_PROJECT = "itsai-dev/subnet32"
+H4_TOKEN = os.environ.get("H4_TOKEN", None)
+API = HfApi(token=H4_TOKEN)
+WANDB_TOKEN = os.environ.get("WANDB_API_KEY", None)
+SUBTENSOR_ENDPOINT=os.environ.get("SUBTENSOR_ENDPOINT", None)
+REPO_ID = "Infin/ai-detection-leaderboard"
+MAX_AVG_LOSS_POINTS = 1
+RETRIES = 5
+DELAY_SECS = 3
+NETUID = 32
+UID_MAIN_VALIDATOR = 147
+BENCHMARK_TOP_AMOUNT = 3
+EVALUATION_STATS_AMOUNT = 5
+
+
+@dataclass
+class ModelData:
+    uid: int
+    coldkey: str
+    hotkey: str
+    incentive: float
+    emission: float
+
+    @classmethod
+    def from_compressed_str(
+        cls,
+        uid: int,
+        coldkey: str,
+        hotkey: str,
+        incentive: float,
+        emission: float,
+    ):
+        """Returns an instance of this class from a compressed string representation"""
+        return ModelData(
+            uid=uid,
+            coldkey=coldkey,
+            hotkey=hotkey,
+            incentive=incentive,
+            emission=emission,
+        )
+
+
+def run_with_retries(func, *args, **kwargs):
+    for i in range(0, RETRIES):
+        try:
+            return func(*args, **kwargs)
+        except (Exception, RuntimeError):
+            if i == RETRIES - 1:
+                raise
+            time.sleep(DELAY_SECS)
+    raise RuntimeError("Should never happen")
+
+
+def get_subtensor_and_metagraph() -> Tuple[bt.subtensor, bt.metagraph]:
+    def _internal() -> Tuple[bt.subtensor, bt.metagraph]:
+        if SUBTENSOR_ENDPOINT:
+            parser = argparse.ArgumentParser()
+            bt.subtensor.add_args(parser)            
+            subtensor = bt.subtensor(config=bt.config(parser=parser, args=["--subtensor.chain_endpoint", SUBTENSOR_ENDPOINT]))
+        else:
+            subtensor = bt.subtensor("finney")
+        metagraph = subtensor.metagraph(NETUID, lite=False)
+        return subtensor, metagraph
+
+    return run_with_retries(_internal)
+
+
+def get_validator_weights(
+    metagraph: bt.metagraph,
+) -> Dict[int, Tuple[float, int, Dict[int, float]]]:
+    """Returns a dictionary of validator UIDs to (vtrust, stake, {uid: weight})."""
+    ret = {}
+    for uid in metagraph.uids.tolist():
+        vtrust = metagraph.validator_trust[uid].item()
+        if vtrust > 0:
+            ret[uid] = (vtrust, metagraph.S[uid].item(), {})
+            for ouid in metagraph.uids.tolist():
+                if ouid == uid:
+                    continue
+                weight = round(metagraph.weights[uid][ouid].item(), 6)
+                if weight > 0:
+                    ret[uid][-1][ouid] = weight
+    return ret
+
+
+def get_subnet_data(
+    metagraph: bt.metagraph
+) -> List[ModelData]:
+    result = []
+    for uid in tqdm(metagraph.uids.tolist()):
+        if metagraph.validator_trust[uid] != 0:
+            continue
+
+        coldkey = metagraph.coldkeys[uid]
+        hotkey = metagraph.hotkeys[uid]
+        incentive = metagraph.incentive[uid].nan_to_num().item()
+        emission = (
+            metagraph.emission[uid].nan_to_num().item() * 20
+        )  # convert to daily TAO
+
+        model_data = None
+        try:
+            model_data = ModelData.from_compressed_str(
+                uid, coldkey, hotkey, incentive, emission
+            )
+        except:
+            continue
+
+        result.append(model_data)
+    return result
+
+
+def is_floatable(x) -> bool:
+    return (
+        isinstance(x, float) and not math.isnan(x) and not math.isinf(x)
+    ) or isinstance(x, int)
+
+
+def get_wandb_runs(project: str, filters: Dict[str, Any]) -> List:
+    """Get the latest runs from Wandb, retrying infinitely until we get them."""
+    while True:
+        api = wandb.Api(api_key=WANDB_TOKEN)
+
+        runs = list(
+            api.runs(
+                project,
+                order="-created_at",
+                filters=filters,
+            )
+        )
+
+        print('Runs amount: ', len(runs))
+        if len(runs) > 0:
+            return runs
+        # WandDB API is quite unreliable. Wait another minute and try again.
+        print("Failed to get runs from Wandb. Trying again in 60 seconds.")
+        time.sleep(10)
+
+
+
+def get_scores(
+    wandb_runs: List,
+) -> Dict[int, Dict[str, Optional[float]]]:
+    result = {}
+    # result = []
+    previous_timestamp = None
+    # Iterate through the runs until we've processed all the uids.
+    
+    for i, run in enumerate(wandb_runs):
+        config_data = run.config
+        vali_uid = config_data['uid']
+
+        # get only last run of each vali except OTF
+        if int(vali_uid) == UID_MAIN_VALIDATOR:
+            if len(result.get(vali_uid, [])) >= 5:
+                continue
+        else:
+            if vali_uid in result:
+                continue
+
+        if run.history().empty:
+            continue
+        
+        data = json.loads(run.summary["original_format_json"])
+
+        timestamp = data["timestamp"]
+
+
+        # Make sure runs are indeed in descending time order.
+        # assert (
+        #     previous_timestamp is None or timestamp < previous_timestamp
+        # ), f"Timestamps are not in descending order: {timestamp} >= {previous_timestamp}"
+        previous_timestamp = timestamp
+
+        if vali_uid not in result:
+            result[vali_uid] = []
+        local_vali_uid_iter = {}
+        for miner_data in list(data['uid_metrics'].values()):
+            local_vali_uid_iter[miner_data['uid']] = {}
+            local_vali_uid_iter[miner_data['uid']].update(miner_data)
+        result[vali_uid].append(local_vali_uid_iter)
+    return result
+
+
+def average_scores(data: List):
+    stats = {}
+
+    for item in data:
+        for key, values in item.items():
+            if key not in stats:
+                stats[key] = {'sums': {'reward': 0, 'fp_score': 0, 'f1_score': 0, 'ap_score': 0, 'penalty': 0}, 'count': 0}
+                stats[key]['uid'] = values['uid']
+                stats[key]['weight'] = values['weight']
+
+            stats[key]['sums']['reward'] += values['reward']
+            stats[key]['sums']['fp_score'] += values['fp_score']
+            stats[key]['sums']['f1_score'] += values['f1_score']
+            stats[key]['sums']['ap_score'] += values['ap_score']
+            stats[key]['sums']['penalty'] += values['penalty']
+            stats[key]['count'] += 1
+
+
+    averages = {}
+    for key, data in stats.items():
+        averages[key] = {field: data['sums'][field] / data['count'] for field in data['sums']}
+        averages[key] = {**averages[key], 'uid': data['uid'], 'weight': data['weight']}
+    return averages
+
+
+def format_score(uid: int, scores, key) -> Optional[float]:
+    if uid in scores:
+        if key in scores[uid]:
+            point = scores[uid][key]
+            if is_floatable(point):
+                return round(scores[uid][key], 6)
+    return None
+
+
+def next_epoch(subtensor: bt.subtensor, block: int) -> int:
+    return (
+        block
+        + subtensor.get_subnet_hyperparameters(NETUID).tempo
+        - subtensor.blocks_since_epoch(NETUID, block)
+    )
+
+
+def get_last_updated_div() -> str:
+    return f"""<div>Last Updated: {datetime.datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")} (UTC)</div>"""
+
+
+def leaderboard_data(
+    leaderboard: List[ModelData],
+    scores: Dict[int, Dict[str, Optional[float]]],
+    show_stale: bool,
+) -> List[List[Any]]:
+    """Returns the leaderboard data, based on models data and UID scores."""
+    # headers=["Top", "UID", "Reward", "F1 Score", "FP Score", "AP Score"],
+
+    rows = [
+        [
+                f"{c.coldkey[:12]}",
+                c.uid,
+                format_score(c.uid, scores, "reward"),
+                format_score(c.uid, scores, "f1_score"),
+                format_score(c.uid, scores, "fp_score"),
+                format_score(c.uid, scores, "ap_score"),
+        ] for c in leaderboard if c.uid in scores
+    ]
+   
+    sorted_rows = sorted(rows, key=lambda x: (x[2], x[0]), reverse=True)
+    if not show_stale:
+        sorted_rows = sorted_rows[:EVALUATION_STATS_AMOUNT]
+    return sorted_rows
+
+
+def restart_space():
+    API.restart_space(repo_id=REPO_ID, token=H4_TOKEN)
+
+
+def main():
+    # To avoid leaderboard failures, infinitely try until we get all data
+    # needed to populate the dashboard
+    while True:
+        # try:
+            subtensor, metagraph = get_subtensor_and_metagraph()
+
+            model_data: List[ModelData] = get_subnet_data(metagraph)
+            model_data.sort(key=lambda x: x.incentive, reverse=False)
+            time_now = datetime.datetime.now(datetime.timezone.utc)
+            n_days_ago = time_now - datetime.timedelta(hours=24)
+ 
+            vali_runs = get_wandb_runs(project=VALIDATOR_WANDB_PROJECT, filters={
+                "$and": [
+                    {
+                        'created_at': {
+                            '$gte': n_days_ago.isoformat()
+                        }
+                    },
+                    {
+                        'state': {
+                            "$in": ["finished"]
+                        }
+                    },
+                    {
+                        'config.version': {
+                            '$in': ["2.3.0", "2.3.1", "2.3.2", "2.4.0"]
+                        }
+                    },
+                    {
+                        'config.uid': {
+                            '$nin': [33, 86, 50, 106]
+                        }
+                    }
+                ]
+            })    
+
+            scores = get_scores(vali_runs)
+
+            averaged_scores = {}
+            for vali_uid, vali_score in scores.items():
+                if len(vali_score) > 1:
+                    averaged_scores.update({vali_uid: average_scores(vali_score)})
+                else:
+                    averaged_scores.update({vali_uid: vali_score[0]})
+
+            scores = averaged_scores
+
+            rows = []
+            for validator_uid, miners in scores.items():                 
+                for miner_uid, stats in miners.items():
+                    row = {'validator_uid': validator_uid}
+                    row.update({k: v for k, v in stats.items()})
+                    rows.append(row)
+
+            miners_stats = pd.DataFrame(rows)
+
+            miners_stats['stake_value'] = miners_stats['validator_uid'].apply(lambda x: metagraph.S[x].item())
+            miners_stats = miners_stats.sort_values(by='stake_value', ascending=False)
+            miners_stats = miners_stats.drop(columns='stake_value')
+
+            main_validator_scores = scores[UID_MAIN_VALIDATOR]
+
+            sorted_main_validator_scores = sorted(main_validator_scores.items(), key=lambda x: x[1]['reward'], reverse=True)
+
+            axons_info = metagraph.axons
+            top_miners = []
+            top_keys = []
+            for score_i in sorted_main_validator_scores:
+                if len(top_miners) >= BENCHMARK_TOP_AMOUNT:
+                    break
+
+                coldkey_i = axons_info[score_i[0]].coldkey
+                if coldkey_i in top_keys:
+                    continue
+
+                top_keys.append(coldkey_i)
+                top_miners.append(score_i)
+                
+            top_miner_score = dict(top_miners)
+            data_list = [{'Model': f'miner_{key}', 
+                        'Average': value['reward'],
+                        'F1 score': value['f1_score'], 
+                        'FP score': value['fp_score'], 
+                        'AP score': value['ap_score']} for key, value in top_miner_score.items()]
+
+            df = pd.DataFrame(data_list)
+            baseline_data = [
+                {'Model': 'baseline: deberta', 'F1 score': 0.863, 'FP score': 0.896, 'AP score': 0.789, 'Average': 0.849}
+            ]
+
+            benchmarks = pd.concat([df, pd.DataFrame(baseline_data)], ignore_index=True)
+            benchmarks = benchmarks.sort_values(by='Average', ascending=False)
+
+            validator_df = get_validator_weights(metagraph)
+            break
+        # except Exception as e:
+        #     print(f"Failed to get data: {e}")
+        #     time.sleep(30)            
+
+    demo = gr.Blocks(css=".typewriter {font-family: 'JMH Typewriter', sans-serif;}")
+    with demo:
+        gr.HTML(FONT)
+        gr.HTML(TITLE)
+        gr.HTML(HEADER)
+
+        if benchmarks is not None:
+            with gr.Accordion("Top Model Benchmarks"):
+                gr.components.Dataframe(benchmarks)
+                gr.HTML("""<div>Fore more information about baseline miner architecture see <a href='https://github.com/It-s-AI/llm-detection/blob/main/neurons/miner.py'>here</a> for the full code.</div>""")
+
+        with gr.Accordion("Evaluation Stats"):
+            gr.HTML(EVALUATION_HEADER)
+            show_stale = gr.Checkbox(label="Show All Miners", interactive=True)
+            leaderboard_table = gr.components.Dataframe(
+                value=leaderboard_data(model_data, main_validator_scores, show_stale.value),
+                headers=["Coldkey", "UID", "Reward", "F1 Score", "FP Score", "AP Score"],
+                datatype=["markdown", "number", "number", "number", "number", "number"],
+                elem_id="leaderboard-table",
+                interactive=False,
+                visible=True,
+            )
+
+            gr.HTML(EVALUATION_DETAILS)
+            show_stale.change(
+                lambda stale: leaderboard_data(model_data, main_validator_scores, stale),
+                inputs=[show_stale],
+                outputs=leaderboard_table,
+            )
+
+        with gr.Accordion("Validator Stats"):
+            model_data.sort(key=lambda x: x.uid, reverse=False)
+
+            values = [
+                    [uid, int(validator_df[uid][1]), round(validator_df[uid][0], 6)]
+                    + [
+                        validator_df[uid][-1].get(c.uid)
+                        for c in model_data
+                        if c.incentive
+                    ]
+                    for uid, _ in sorted(
+                        zip(
+                            validator_df.keys(),
+                            [validator_df[x][1] for x in validator_df.keys()],
+                        ),
+                        key=lambda x: x[1],
+                        reverse=True,
+                    )
+                ]
+            
+            averages = np.nanmean(np.array(values, dtype=float)[:, 3:], axis=0)
+            averages = np.around(averages, decimals=6)
+
+            values.append(["Average", 0, 0] + averages.tolist())
+
+            gr.components.Dataframe(
+                value=values,
+                headers=["UID", "Stake (τ)", "V-Trust"]
+                + [
+                    f"{c.uid}/reward"
+                    for c in model_data
+                    if c.incentive
+                ]
+                ,
+                datatype=["markdown", "number", "number"]
+                + ["number" for c in model_data if c.incentive]
+                ,
+                interactive=False,
+                visible=True,
+            )
+
+        def get_miner_stats(uid):
+            local_stats = miners_stats[miners_stats['uid'] == int(uid)]
+            local_stats.drop('penalty', axis=1, inplace=True)
+            local_stats.columns = ["Validator UID", "Reward", "FP Score", "F1 Score", "AP Score", "UID", "Weight"]
+            local_stats = local_stats[["Validator UID", "UID", "Weight", "Reward", "FP Score", "F1 Score", "AP Score"]]
+            return local_stats
+
+        with gr.Accordion("Get your miner stats"):
+            with gr.Row():
+                input_text = gr.Textbox(label="Enter your Miner ID")
+                submit_button = gr.Button("Get Stats")
+
+            output_df = gr.components.DataFrame(
+                headers=["Validator UID", "Miner UID"] + ["Weight", "Reward"] + ["FP Score", "F1 Score", "AP Score"],
+                datatype=["number", "number"] + ["number", "number", "number", "number", "number"],
+                interactive=False,
+                visible=True
+            )
+
+            submit_button.click(
+                fn=get_miner_stats,
+                inputs=input_text,
+                outputs=output_df
+            )
+
+        gr.HTML(value=get_last_updated_div())
+
+    scheduler = BackgroundScheduler()
+    scheduler.add_job(
+        restart_space, "interval", seconds=60 * 60 * 24
+    )  # restart every 45 minutes
+    scheduler.start()
+
+    demo.launch(share=True)
+
+main()

requirements.txt

@@ -0,0 +1,148 @@
+aiofiles==23.2.1
+aiohttp==3.9.0b0
+aiosignal==1.3.1
+altair==5.3.0
+ansible==6.7.0
+ansible-core==2.13.13
+ansible-vault==2.1.0
+anyio==4.3.0
+appdirs==1.4.4
+APScheduler==3.10.4
+async-timeout==4.0.3
+attrs==23.2.0
+backoff==2.2.1
+base58==2.1.1
+bittensor==6.11.0
+black==23.7.0
+certifi==2024.2.2
+cffi==1.16.0
+charset-normalizer==3.3.2
+click==8.1.7
+colorama==0.4.6
+contourpy==1.2.1
+cryptography==42.0.0
+cycler==0.12.1
+cytoolz==0.12.3
+ddt==1.6.0
+decorator==5.1.1
+docker-pycreds==0.4.0
+ecdsa==0.19.0
+eth-hash==0.7.0
+eth-keys==0.5.1
+eth-typing==4.2.2
+eth-utils==2.3.1
+exceptiongroup==1.2.1
+fastapi==0.99.1
+ffmpy==0.3.2
+filelock==3.14.0
+fonttools==4.51.0
+frozenlist==1.4.1
+fsspec==2024.3.1
+fuzzywuzzy==0.18.0
+gitdb==4.0.11
+GitPython==3.1.43
+gradio==3.50.2
+gradio_client==0.6.1
+h11==0.14.0
+httpcore==1.0.5
+httpx==0.27.0
+huggingface-hub==0.22.2
+idna==3.7
+importlib_resources==6.4.0
+iniconfig==2.0.0
+Jinja2==3.1.3
+jsonschema==4.21.1
+jsonschema-specifications==2023.12.1
+kiwisolver==1.4.5
+Levenshtein==0.25.1
+markdown-it-py==3.0.0
+MarkupSafe==2.1.5
+matplotlib==3.8.4
+mdurl==0.1.2
+more-itertools==10.2.0
+mpmath==1.3.0
+msgpack==1.0.8
+msgpack-numpy-opentensor==0.5.0
+multidict==6.0.5
+munch==2.5.0
+mypy-extensions==1.0.0
+nest-asyncio==1.6.0
+netaddr==1.2.1
+networkx==3.3
+numpy==1.26.4
+nvidia-cublas-cu12==12.1.3.1
+nvidia-cuda-cupti-cu12==12.1.105
+nvidia-cuda-nvrtc-cu12==12.1.105
+nvidia-cuda-runtime-cu12==12.1.105
+nvidia-cudnn-cu12==8.9.2.26
+nvidia-cufft-cu12==11.0.2.54
+nvidia-curand-cu12==10.3.2.106
+nvidia-cusolver-cu12==11.4.5.107
+nvidia-cusparse-cu12==12.1.0.106
+nvidia-nccl-cu12==2.20.5
+nvidia-nvjitlink-cu12==12.4.127
+nvidia-nvtx-cu12==12.1.105
+orjson==3.10.1
+packaging==24.0
+pandas==2.2.2
+password-strength==0.0.3.post2
+pathspec==0.12.1
+pillow==10.3.0
+platformdirs==4.2.1
+pluggy==1.5.0
+protobuf==4.25.3
+psutil==5.9.8
+py==1.11.0
+py-bip39-bindings==0.1.11
+py-ed25519-zebra-bindings==1.0.1
+py-sr25519-bindings==0.2.0
+pycparser==2.22
+pycryptodome==3.20.0
+pydantic==1.10.15
+pydub==0.25.1
+Pygments==2.17.2
+PyNaCl==1.5.0
+pyparsing==3.1.2
+pytest==8.2.0
+pytest-asyncio==0.23.6
+python-dateutil==2.9.0.post0
+python-dotenv==1.0.1
+python-Levenshtein==0.25.1
+python-multipart==0.0.9
+python-statemachine==2.1.2
+pytz==2024.1
+PyYAML==6.0.1
+rapidfuzz==3.8.1
+referencing==0.35.0
+requests==2.31.0
+resolvelib==0.8.1
+retry==0.9.2
+rich==13.7.1
+rpds-py==0.18.0
+scalecodec==1.2.7
+semantic-version==2.10.0
+sentry-sdk==2.0.1
+setproctitle==1.3.3
+shtab==1.6.5
+six==1.16.0
+smmap==5.0.1
+sniffio==1.3.1
+starlette==0.27.0
+substrate-interface==1.7.5
+sympy==1.12
+termcolor==2.4.0
+tomli==2.0.1
+toolz==0.12.1
+torch==2.3.0
+tqdm==4.66.2
+triton==2.3.0
+typing_extensions==4.11.0
+tzdata==2024.1
+tzlocal==5.2
+urllib3==2.2.1
+uvicorn==0.22.0
+wandb==0.16.6
+websocket-client==1.8.0
+websockets==11.0.3
+xxhash==3.4.1
+yarl==1.9.4