Merge branch 'main' into feat/reserved-weights

Author: sangar-1028

neurons/validators/genie_validator.py

@@ -84,7 +84,8 @@ async def query_miners(self):
                 SeoChallenge,
                 #QualityChallenge, 
                 SeoChallenge,
-                BalancedChallenge,
+                SeoChallenge,
+                SeoChallenge,
             ]  
 
             with self.lock:

neurons/validators/score_manager.py

@@ -8,6 +8,7 @@
 from typing import List
 
 from webgenie.base.neuron import BaseNeuron
+
 from webgenie.challenges.challenge import Challenge, RESERVED_WEIGHTS
 from webgenie.constants import CONSIDERING_SESSION_COUNTS, __STATE_VERSION__, WORK_DIR
 from webgenie.helpers.weights import save_file_to_wandb
@@ -133,13 +134,11 @@ def update_scores(self, rewards: np.ndarray, uids: List[int], challenge: Challen
         self.total_scores[uids] += rewards
         self.solved_tasks[uids] += 1
 
-        avg_scores = np.zeros(self.neuron.metagraph.n, dtype=np.float32)
-        for uid in range(self.neuron.metagraph.n):
-            if self.solved_tasks[uid] >= max(1, self.number_of_tasks / 2):
-                avg_scores[uid] = self.total_scores[uid] / self.solved_tasks[uid]
-            else:
-                avg_scores[uid] = 0
-        winner = np.argmax(avg_scores) if max(avg_scores) > 0 else -1
+        winner = self.get_winner(
+            self.total_scores,
+            self.solved_tasks,
+            self.number_of_tasks,
+        )
 
         current_session_results = {
             "session": session,
@@ -160,13 +159,31 @@ def update_scores(self, rewards: np.ndarray, uids: List[int], challenge: Challen
 
         console = Console()
         self.print_session_result(session, console)
+    
+    def is_blacklisted(self, uid: int):
+        blacklisted_coldkeys = ["5G9yTkkDd39chZiyvKwNsQvzqbbPgdiLtdb4sCR743f4MuRY"]
+        return self.neuron.metagraph.axons[uid].coldkey in blacklisted_coldkeys
+
+    def get_winner(self, total_scores: np.ndarray, solved_tasks: np.ndarray, number_of_tasks: int):
+        avg_scores = np.zeros(self.neuron.metagraph.n, dtype=np.float32)
+        for uid in range(self.neuron.metagraph.n):
+            if self.is_blacklisted(uid):
+                continue
+            
+            if solved_tasks[uid] >= max(1, number_of_tasks - MAX_UNANSWERED_TASKS):
+                avg_scores[uid] = total_scores[uid] / solved_tasks[uid]
+            else:
+                avg_scores[uid] = 0
+        winner = np.argmax(avg_scores) if max(avg_scores) > 0 else -1
+        return winner
 
     def get_scores(self, session_upto: int):
         scores = np.zeros(self.neuron.metagraph.n, dtype=np.float32)
         for session_number in self.session_results:
             if (session_number <= session_upto - CONSIDERING_SESSION_COUNTS or 
                 session_number > session_upto):
                 continue
+
             try:
                 winner = self.session_results[session_number]["winner"]
                 competition_type = self.session_results[session_number]["competition_type"]
@@ -175,6 +192,7 @@ def get_scores(self, session_upto: int):
                 scores[winner] += RESERVED_WEIGHTS[competition_type]
             except Exception as e:
                 bt.logging.warning(f"Error getting scores: {e}")
+
         return scores
         # scores = np.zeros(self.neuron.metagraph.n, dtype=np.float32)
         # tiny_weight = 1 / 128
@@ -212,7 +230,7 @@ def print_session_result(self, session_upto: int, console: Console):
 
             avg_scores = np.zeros(self.neuron.metagraph.n, dtype=np.float32)
             for uid in range(self.neuron.metagraph.n):
-                if solved_tasks[uid] >= max(1, number_of_tasks / 2):
+                if solved_tasks[uid] >= max(1, number_of_tasks - MAX_UNANSWERED_TASKS):
                     avg_scores[uid] = scores[uid] / solved_tasks[uid]
                 else:
                     avg_scores[uid] = 0

neurons/validators/validator.py

@@ -81,7 +81,7 @@ def __init__(self, config=None):
 
         if not AXON_OFF:
             self.serve_axon()
-
+            
     def resync_metagraph(self):
         # Copies state of metagraph before syncing.
         previous_metagraph = copy.deepcopy(self.metagraph)

webgenie/constants.py

@@ -3,6 +3,7 @@
 import psutil
 # Change this value when updating your code base.
 # Define the version of the webgenie.
+
 __VERSION__ = "1.1.20" # version
 
 SPEC_VERSION = (
@@ -81,14 +82,16 @@
 
 WANDB_ENTITY_NAME = os.getenv("WANDB_ENTITY_NAME") # wandb entity name
 
-VPERMIT_TAO_LIMIT = 1000 # vpermit tao limit
+VPERMIT_TAO_LIMIT = 100000 # vpermit tao limit
 
 AXON_OFF = os.getenv("AXON_OFF", "False").lower() == "true" # axon off
 
 NEURON_EPOCH_LENGTH = int(os.getenv("NEURON_EPOCH_LENGTH", 25)) # neuron epoch length
 
 MAX_NUMBER_OF_TASKS_PER_SESSION = 18 # max number of tasks per session
 
+MAX_UNANSWERED_TASKS = 3 # max unanswered tasks
+
 NUMBER_OF_CONCURRENT_WORKERS = max(
     1,
     min(

webgenie/rewards/quality_reward.py

@@ -34,6 +34,7 @@ async def _get_score(self, solution: Solution) -> float:
             return 0
 
     async def reward(self, task: Task, solutions: List[Solution]) -> np.ndarray:
+        return np.array([1.0] * len(solutions))
         bt.logging.info(f"Rewarding task in quality reward")
         get_score_tasks = [self._get_score(solution) for solution in solutions]
         scores = await asyncio.gather(*get_score_tasks)