Merge pull request #142 from web-genie-ai/feat/increase-task-count

Feat/increase task count

Author: sangar-1028

neurons/validators/genie_validator.py

@@ -28,9 +28,7 @@
     SeoChallenge,
     BalancedChallenge,
 )
-from webgenie.datasets.central_dataset import (
-    CentralDataset,
-)
+from webgenie.datasets import CentralDataset
 from webgenie.helpers.htmls import preprocess_html, is_valid_resources
 from webgenie.helpers.images import image_debug_str
 from webgenie.helpers.llms import set_seed
@@ -277,7 +275,7 @@ async def synthensize_task(self, session:int, task_number:int):
                 weights=[weight for _, weight in self.task_generators],
             )[0]
 
-            task, synapse = await task_generator.generate_task(session, task_number)
+            task, synapse = await task_generator.generate_task(session=session, task_number=task_number)
             with self.lock:
                 self.synthetic_tasks.append((task, synapse))
 
@@ -286,69 +284,44 @@ async def synthensize_task(self, session:int, task_number:int):
             bt.logging.error(f"Error in synthensize_task: {e}")
             raise e
 
-    def get_seed(self, session: int, task_index: int, hash_cache: dict = {}) -> int:
-        try:
-            method = "GET"
-            url = "http://209.126.9.130:18000/api/v1/task/seed"
-            response = requests.request(method, url, params={"session": session, "task_number": task_index})
-            if response.status_code == 200:
-                response_json = response.json()
-                success = response_json["success"]
-                if not success:
-                    raise Exception(f"Failed to get seed from API: {seed}")
-                
-                seed = response_json["seed"], response_json["task_id_seed"]
-                
-                if seed is None:
-                    raise Exception(f"Seed is None")
-                return seed
-            else:
-                raise Exception(f"Failed to get seed from API: {response.status_code}")
-            
-        except Exception as e:
-            raise e
-        
-        # if session not in hash_cache:
-        #     session_start_block = session * SESSION_WINDOW_BLOCKS
-        #     subtensor = self.neuron.subtensor
-        #     block_hash = subtensor.get_block_hash(session_start_block)
-        #     hash_cache[session] = int(block_hash[-15:], 16)
-        # return int(hash_cache[session] + task_index)
+    def get_seed(self, session: int, task_number: int, hash_cache: dict = {}) -> int:
+        if session not in hash_cache:
+            session_start_block = session * SESSION_WINDOW_BLOCKS
+            subtensor = self.neuron.subtensor
+            block_hash = subtensor.get_block_hash(session_start_block)
+            hash_cache[session] = int(block_hash[-15:], 16)
+        return int(hash_cache[session] + task_number)
 
     async def forward(self):
         try:
             with self.lock:
                 session = self.neuron.session
                 if self.neuron.score_manager.current_session != session:
-                    task_index = 0
+                    task_number = 0
                 else:
-                    task_index = self.neuron.score_manager.number_of_tasks
+                    task_number = self.neuron.score_manager.number_of_tasks
 
-                session = int(session)
-                task_index = int(task_index)
-                        
-            if task_index >= MAX_NUMBER_OF_TASKS_PER_SESSION:
+            if task_number >= MAX_NUMBER_OF_TASKS_PER_SESSION:
                 return
 
+            bt.logging.info(f"Forwarding task #{task_number} in session #{session}")
+            # seed = self.get_seed(session, task_number)
 
-            bt.logging.info(f"Forwarding task #{task_index} in session #{session}")
-            #seed, task_id_seed = self.get_seed(session, task_index)
-            
-            #bt.logging.info(f"Random seed: {seed} | task_id_seed: {task_id_seed}")
-            #random.seed(seed)
-            #set_seed(seed)
+            # bt.logging.info(f"Init random with seed: {seed}")
+            # random.seed(seed)
+            # set_seed(seed)
 
             try:
-                await self.synthensize_task(session, task_index)
+                await self.synthensize_task(session, task_number)
                 task, synapse = self.synthetic_tasks[-1]
-                task.task_id = f"{session}_{task_index}"
+                task.task_id = f"{session}_{task_number}"
                 synapse.task_id = task.task_id
             except Exception as e:
                 bt.logging.error(
                     f"Error in synthensize_task: {e}"
+                    f"Retrying..."
                 )
-                return
-            
+        
             await self.query_miners()
             await self.score()
         except Exception as e:

neurons/validators/validator.py

@@ -148,6 +148,7 @@ def set_weights(self):
 
         self.print_weights(raw_weights)
 
+        return
         with self.lock:
             # Process the raw weights to final_weights via subtensor limitations.
             (

webgenie/constants.py

@@ -3,8 +3,7 @@
 import psutil
 # Change this value when updating your code base.
 # Define the version of the webgenie.
-
-__VERSION__ = "1.1.30" # version
+__VERSION__ = "1.2.0" # version
 
 SPEC_VERSION = (
     (1000 * int(__VERSION__.split(".")[0]))

webgenie/datasets/central_dataset.py

@@ -18,9 +18,11 @@ def __init__(self):
     async def generate_context(self) -> DatasetEntry:
         pass
 
-    async def generate_context(self, session:int, task_number:int)->DatasetEntry:
+    async def generate_context(self, **kwargs)->DatasetEntry:
         try:
             bt.logging.info("Generating Central context")
+            session = kwargs.get("session")
+            task_number = kwargs.get("task_number")
             html = self.get_html(session, task_number)
             return DatasetEntry(
                 src="central",

webgenie/tasks/image_task_generator.py

@@ -49,11 +49,11 @@ def __init__(self):
             QUALITY_METRIC_NAME: QualityReward(),
         }
 
-    async def generate_task(self) -> Tuple[Task, bt.Synapse]:
+    async def generate_task(self, **kwargs) -> Tuple[Task, bt.Synapse]:
         bt.logging.info("Generating Image task")
 
         dataset, _ = random.choices(self.datasets, weights=[weight for _, weight in self.datasets])[0]
-        dataset_entry = await dataset.generate_context()
+        dataset_entry = await dataset.generate_context(**kwargs)
         bt.logging.debug(f"Generated dataset entry: {dataset_entry.url}")
 
         ground_truth_html = preprocess_html(dataset_entry.ground_truth_html)

webgenie/tasks/task_generator.py

@@ -11,7 +11,7 @@ class TaskGenerator:
     def __init__(self):
         self.metrics: dict[str, Reward] = {}
 
-    async def generate_task(self) -> Tuple[Task, bt.Synapse]:
+    async def generate_task(self, **kwargs) -> Tuple[Task, bt.Synapse]:
         pass
 
     async def calculate_scores(self, task: Task, solutions: List[Solution]) -> dict[str, np.ndarray]: