adds sampling mode to back-end

validators/base.py

@@ -13,6 +13,7 @@ class QueryValidatorParams:
     timeout: int
     prefer: str
     request: Request
+    sampling_mode: str
 
     @staticmethod
     def from_request(request: Request):
@@ -26,6 +27,7 @@ class QueryValidatorParams:
             timeout=data.get("timeout", 10),
             prefer=data.get("prefer", "longest"),
             request=request,
+            sampling_mode=data.get("sampling_mode", "random"),
         )
 
 

validators/sn1_validator_wrapper.py

@@ -5,31 +5,34 @@ from prompting.utils.uids import get_random_uids
 from prompting.protocol import StreamPromptingSynapse
 from .base import QueryValidatorParams, ValidatorAPI
 from aiohttp.web_response import Response, StreamResponse
-from dataclasses import dataclass
-from typing import List
 from .streamer import AsyncResponseDataStreamer
-
-
-@dataclass
-class ProcessedStreamResponse:
-    streamed_chunks: List[str]
-    streamed_chunks_timings: List[float]
-    synapse: StreamPromptingSynapse
+from .validator_utils import get_top_incentive_uids
 
 
 class S1ValidatorAPI(ValidatorAPI):
     def __init__(self):
         self.validator = Validator()
 
+    def sample_uids(self, params: QueryValidatorParams):    
+        if params.sampling_mode == "random":
+            uids = get_random_uids(
+                self.validator, k=params.k_miners, exclude=params.exclude or []
+            ).tolist()
+            return uids
+        if params.sampling_mode == "top_incentive":
+            metagraph = self.validator.metagraph
+            vpermit_tao_limit = self.validator.config.neuron.vpermit_tao_limit
+            
+            top_uids = get_top_incentive_uids(metagraph, k=params.k_miners, vpermit_tao_limit=vpermit_tao_limit)
+            
+            return top_uids
 
     async def get_stream_response(self, params: QueryValidatorParams) -> StreamResponse:
         # Guess the task name of current request
         # task_name = utils.guess_task_name(params.messages[-1])
 
         # Get the list of uids to query for this step.
-        uids = get_random_uids(
-            self.validator, k=params.k_miners, exclude=params.exclude or []
-        ).tolist()
+        uids =  self.sample_uids(params)
         axons = [self.validator.metagraph.axons[uid] for uid in uids]
 
         # Make calls to the network with the prompt.

validators/validator_utils.py

@@ -0,0 +1,23 @@
+from typing import List
+from prompting.utils.uids import check_uid_availability
+
+
+def get_top_incentive_uids(metagraph, k: int, vpermit_tao_limit: int) -> List[int]:
+    miners_uids = list(map(int, filter(lambda uid: check_uid_availability(metagraph, uid, vpermit_tao_limit), metagraph.uids)))
+    
+    # Builds a dictionary of uids and their corresponding incentives
+    all_miners_incentives = {
+        "miners_uids": miners_uids,
+        "incentives": list(map(lambda uid: metagraph.I[uid], miners_uids))
+    }
+    
+    # Zip the uids and their corresponding incentives into a list of tuples
+    uid_incentive_pairs = list(zip(all_miners_incentives['miners_uids'], all_miners_incentives['incentives']))
+
+    # Sort the list of tuples by the incentive value in descending order
+    uid_incentive_pairs_sorted = sorted(uid_incentive_pairs, key=lambda x: x[1], reverse=True)
+
+    # Extract the top 10 uids
+    top_k_uids = [uid for uid, incentive in uid_incentive_pairs_sorted[:k]]
+    
+    return top_k_uids