Merge pull request #83 from Datura-ai/feature/code-refactor

Feature/code refactor

Author: surcyf123

cortext/__init__.py

@@ -19,7 +19,7 @@
 
 
 # version must stay on line 22
-__version__ = "4.0.3"
+__version__ = "4.0.4"
 version_split = __version__.split(".")
 __spec_version__ = (
         (1000 * int(version_split[0]))

organic.py

@@ -206,4 +206,6 @@ async def main():
     response = await query_miner(dendrite, axon_to_use, synapse, timeout, streaming)
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    asyncio.run(main())
+
+    

validators/config.py

@@ -16,6 +16,7 @@ def __init__(self):
         self.ASYNC_TIME_OUT = int(os.getenv('ASYNC_TIME_OUT', 60))
         self.BT_SUBTENSOR_NETWORK = 'test' if self.ENV == 'test' else 'finney'
         self.SLEEP_PER_ITERATION = 1
+        self.IMAGE_VALIDATOR_CHOOSE_PROBABILITY = 0.03
 
     @staticmethod
     def check_required_env_vars():
@@ -58,9 +59,11 @@ def get_config() -> bt.config:
 
     bt.axon.check_config(bt_config_)
     bt.logging.check_config(bt_config_)
+
+    local_host_str = ['local', '127.0.0.1', '0.0.0.0']
     if 'test' in bt_config_.subtensor.chain_endpoint:
         bt_config_.subtensor.network = 'test'
-    elif 'local' in bt_config_.subtensor.chain_endpoint:
+    elif any(word in bt_config_.subtensor.chain_endpoint for word in local_host_str):
         bt_config_.subtensor.network = 'local'
     else:
         bt_config_.subtensor.network = 'finney'

validators/services/validators/base_validator.py

@@ -43,8 +43,7 @@ async def load_questions(self, available_uids, item_type: str = "text", vision=F
         for index, uid in enumerate(available_uids):
 
             if item_type == "images":
-                messages = await utils.get_question("images", len(available_uids))
-                content = " ".join(messages)
+                content  = await utils.get_question("images", len(available_uids))
                 self.uid_to_questions[uid] = content  # Store messages for each UID
             elif item_type == "text":
                 question = await utils.get_question("text", len(available_uids), vision)

validators/services/validators/constants.py

@@ -10,3 +10,43 @@
                  "claude-3-5-sonnet-20240620"]
 DEFAULT_NUM_UID_PICK = 30
 DEFAULT_NUM_UID_PICK_ANTHROPIC = 1
+TEXT_VALI_MODELS_WEIGHTS = {
+    "AnthropicBedrock": {
+        "anthropic.claude-v2:1": 1
+    },
+    "OpenAI": {
+        "gpt-4o": 1,
+        "gpt-4-1106-preview": 1,
+        "gpt-3.5-turbo": 1,
+        "gpt-3.5-turbo-16k": 1,
+        "gpt-3.5-turbo-0125": 1,
+    },
+    "Gemini": {
+        "gemini-pro": 1,
+        "gemini-1.5-flash": 1,
+        "gemini-1.5-pro": 1,
+    },
+    "Anthropic": {
+        "claude-3-5-sonnet-20240620": 1,
+        "claude-3-opus-20240229": 1,
+        "claude-3-sonnet-20240229": 1,
+        "claude-3-haiku-20240307": 1
+    },
+    "Groq": {
+        "gemma-7b-it": 1,
+        "llama3-70b-8192": 1,
+        "llama3-8b-8192": 1,
+        "mixtral-8x7b-32768": 1,
+    },
+    "Bedrock": {
+        "anthropic.claude-3-sonnet-20240229-v1:0": 1,
+        "cohere.command-r-v1:0": 1,
+        "meta.llama2-70b-chat-v1": 1,
+        "amazon.titan-text-express-v1": 1,
+        "mistral.mistral-7b-instruct-v0:2": 1,
+        "ai21.j2-mid-v1": 1,
+        "anthropic.claude-3-5-sonnet-20240620-v1:0": 1,
+        "anthropic.claude-3-opus-20240229-v1:0": 1,
+        "anthropic.claude-3-haiku-20240307-v1:0": 1
+    }
+}

validators/services/validators/text_validator.py

@@ -2,6 +2,7 @@
 import random
 from typing import AsyncIterator
 
+from cortext.reward import model
 from validators.services.bittensor import bt_validator as bt
 from . import constants
 import cortext.reward
@@ -99,9 +100,11 @@ async def start_query(self, available_uids):
                 syn = StreamPrompting(messages=messages, model=self.model, seed=self.seed, max_tokens=self.max_tokens,
                                       temperature=self.temperature, provider=self.provider, top_p=self.top_p,
                                       top_k=self.top_k)
+
+                image = image if image else ''
                 bt.logging.info(
                     f"Sending {syn.model} {self.query_type} request to uid: {uid}, "
-                    f"timeout {self.timeout}: {syn.messages[0]['content']}"
+                    f"timeout {self.timeout}: {syn.messages[0]['content']} {image}"
                 )
                 task = self.query_miner(self.metagraph, uid, syn)
                 query_tasks.append(task)
@@ -119,35 +122,10 @@ def select_random_provider_and_model(self):
         self.provider = random.choice(providers)
         self.num_uids_to_pick = constants.DEFAULT_NUM_UID_PICK
 
-        if self.provider == "AnthropicBedrock":
-            self.model = "anthropic.claude-v2:1"
-
-        elif self.provider == "OpenAI":
-            models = ["gpt-4o", "gpt-4-1106-preview", "gpt-3.5-turbo", "gpt-3.5-turbo-16k", "gpt-3.5-turbo-0125"]
-            self.model = random.choice(models)
-
-        elif self.provider == "Gemini":
-            models = ["gemini-pro", "gemini-1.5-flash", "gemini-1.5-pro"]
-            self.model = random.choice(models)
-
-        elif self.provider == "Anthropic":
-            models = ["claude-3-5-sonnet-20240620", "claude-3-opus-20240229", "claude-3-sonnet-20240229",
-                      "claude-3-haiku-20240307"]
-            self.model = random.choice(models)
-
-        elif self.provider == "Groq":
-            models = ["gemma-7b-it", "llama3-70b-8192", "llama3-8b-8192", "mixtral-8x7b-32768"]
-            self.model = random.choice(models)
-
-        elif self.provider == "Bedrock":
-            models = [
-                "anthropic.claude-3-sonnet-20240229-v1:0", "cohere.command-r-v1:0",
-                "meta.llama2-70b-chat-v1", "amazon.titan-text-express-v1",
-                "mistral.mistral-7b-instruct-v0:2", "ai21.j2-mid-v1", "anthropic.claude-3-5-sonnet-20240620-v1:0"
-                                                                      "anthropic.claude-3-opus-20240229-v1:0",
-                "anthropic.claude-3-haiku-20240307-v1:0"
-            ]
-            self.model = random.choice(models)
+        model_to_weights = constants.TEXT_VALI_MODELS_WEIGHTS[self.provider]
+        self.model = random.choices(list(model_to_weights.keys()),
+                                    weights=list(model_to_weights.values()), k=1)[0]
+
         return self.num_uids_to_pick
 
     def should_i_score(self):

validators/weight_setter.py

@@ -219,29 +219,22 @@ async def perform_synthetic_scoring_and_update_weights(self):
                 for uid, score in uid_to_scores.items():
                     self.total_scores[uid] += score
 
-                steps_since_last_update = steps_passed % iterations_per_set_weights
-
-                if steps_since_last_update == iterations_per_set_weights - 1:
-                    await self.update_weights(steps_passed)
-                else:
-                    bt.logging.info(
-                        f"Updating weights in {iterations_per_set_weights - steps_since_last_update - 1} iterations."
-                    )
-
                 # if we want to slow down the speed of the validator steps
                 await asyncio.sleep(app_config.SLEEP_PER_ITERATION)
 
                 if (self.subtensor.block - cur_block) >= 360:
-                    print("refreshing metagraph...")
+                    bt.logging.info("refreshing metagraph...")
                     cur_block = self.subtensor.block
                     await self.refresh_metagraph()
+                    bt.logging.info("updating weights...")
+                    await self.update_weights(steps_passed)
 
     @staticmethod
     def select_validator():
         rand = random.random()
         text_validator = ValidatorRegistryMeta.get_class('TextValidator')()
         image_validator = ValidatorRegistryMeta.get_class('ImageValidator')()
-        if rand < 0.9:
+        if rand > app_config.IMAGE_VALIDATOR_CHOOSE_PROBABILITY:
             bt.logging.info("text_validator is selected.")
             return text_validator
         else:
@@ -250,14 +243,14 @@ def select_validator():
 
     async def get_available_uids(self):
         """Get a dictionary of available UIDs and their axons asynchronously."""
+        await self.dendrite.aclose_session()
         tasks = {uid.item(): self.check_uid(self.metagraph.axons[uid.item()], uid.item()) for uid in
                  self.metagraph.uids}
         results = await asyncio.gather(*tasks.values())
 
         # Create a dictionary of UID to axon info for active UIDs
         available_uids = {uid: axon_info for uid, axon_info in zip(tasks.keys(), results) if axon_info is not None}
 
-        await self.dendrite.aclose_session()
         return available_uids
 
     async def check_uid(self, axon, uid):
@@ -326,7 +319,7 @@ async def set_weights(self, scores):
                 wallet=self.wallet,
                 uids=self.metagraph.uids,
                 weights=self.moving_average_scores,
-                wait_for_inclusion=False,
+                wait_for_inclusion=True,
                 version_key=cortext.__weights_version__,
             )
         )