Subtensor and Normalization updates

bittensor/_neuron/text/core_validator/__init__.py

@@ -237,7 +237,7 @@ def add_args( cls, parser ):
         parser.add_argument('--neuron.wait_for_finalization', action='store_true', help='''when setting weights the miner waits for trnasaction finalization.''', default=False)
         parser.add_argument('--neuron.forward_num', type=int, help='''How much forward request before a backward call.''', default=3)
         parser.add_argument('--neuron.validation_synapse', type=str, help='''Synapse used for validation.''', default='TextCausalLMNext', choices = ['TextCausalLMNext', 'TextCausalLM'])
-        parser.add_argument('--neuron.exclude_quantile', type=float, help='Exclude the lowest quantile from weight setting.', default=0.1)
+        parser.add_argument('--neuron.exclude_quantile', type=float, help='Exclude the lowest quantile from weight setting. (default value: -1, pulling from subtensor directly)', default=-1)
 
     @classmethod
     def config ( cls ):
@@ -388,7 +388,7 @@ def run_epoch( self ):
         sequence_length = self.subtensor.validator_sequence_length
         validation_len = self.config.neuron.validation_len  # Number of tokens to holdout for phrase validation beyond sequence context
         min_allowed_weights = self.subtensor.min_allowed_weights
-        max_allowed_ratio = self.subtensor.max_allowed_min_max_ratio
+        max_weight_limit = self.subtensor.max_weight_limit
         blocks_per_epoch = self.subtensor.validator_epoch_length if self.config.neuron.blocks_per_epoch == -1 else self.config.neuron.blocks_per_epoch
         epochs_until_reset = self.subtensor.validator_epochs_per_reset if self.config.neuron.epochs_until_reset == -1 else self.config.neuron.epochs_until_reset
 
@@ -410,7 +410,7 @@ def run_epoch( self ):
         if self.config.using_wandb:
             wandb.log({'era/batch_size': batch_size, 'era/sequence_length': sequence_length,
                        'era/validation_len': validation_len,
-                       'era/min_allowed_weights': min_allowed_weights, 'era/max_allowed_ratio': max_allowed_ratio,
+                       'era/min_allowed_weights': min_allowed_weights, 'era/max_weight_limit': max_weight_limit,
                        'era/blocks_per_epoch': blocks_per_epoch, 'era/epochs_until_reset': epochs_until_reset},
                       step=current_block)
 
@@ -572,8 +572,8 @@ def run_epoch( self ):
               f'[dim]weights[/dim] sum:{sample_weights.sum().item():.2g} '
               f'[white] max:[bold]{sample_weights.max().item():.4g}[/bold] / '
               f'min:[bold]{sample_weights.min().item():.4g}[/bold] [/white] '
-              f'\[{sample_weights.max().item() / sample_weights.min().item():.1f}:1] '
-              f'({max_allowed_ratio} allowed)')
+              f'\[{sample_weights.max().item()}:1] '
+              f'({max_weight_limit} allowed)')
 
         self.subtensor.set_weights(
             uids=sample_uids.detach().to('cpu'),
@@ -678,7 +678,7 @@ def calculate_weights(self, responsive_uids: Set, queried_uids: Set):
 
         # === Randomize UIDs in preferred order (responsive -> queried -> rest) ===
         min_allowed_weights = self.subtensor.min_allowed_weights
-        max_allowed_ratio = self.subtensor.max_allowed_min_max_ratio
+        max_weight_limit = self.subtensor.max_weight_limit
 
         non_responsive_uids = queried_uids - responsive_uids
         non_queried_uids = set(range(self.metagraph.n)) - queried_uids
@@ -708,32 +708,35 @@ def calculate_weights(self, responsive_uids: Set, queried_uids: Set):
         sample_uids = preferred_uids[:weights_to_set]  # slice to weights_to_set
         sample_weights = neuron_weights[:weights_to_set]  # slice to weights_to_set
 
-        logger.info(f'{len(sample_weights)} Shapley values | min:{sample_weights.min()} max:{sample_weights.max()}')
+        # === If no uids responds, return ===
+        if len(sample_uids) == 0:
+            return sample_uids, sample_weights
 
         # === Exclude lowest quantile from weight setting ===
         max_exclude = (len(sample_weights) - min_allowed_weights) / len(sample_weights)  # max excludable weight quantile
+        quantile = self.subtensor.validator_exclude_quantile if self.config.neuron.exclude_quantile == -1 else self.config.neuron.exclude_quantile 
         if 0 < max_exclude:
-            exclude_quantile = min([self.config.neuron.exclude_quantile, max_exclude])  # reduce quantile to meet min_allowed_weights
+            exclude_quantile = min([quantile , max_exclude])  # reduce quantile to meet min_allowed_weights
             lowest_quantile = sample_weights.quantile(exclude_quantile)  # find lowest quantile threshold
             sample_uids = sample_uids[lowest_quantile <= sample_weights]  # exclude uids with weights below quantile
             sample_weights = sample_weights[lowest_quantile <= sample_weights]  # exclude weights below quantile
 
             logger.info(f'Exclude {exclude_quantile} quantile ({lowest_quantile}) | '
                         f'{len(sample_weights)} Shapley values | min:{sample_weights.min()} max:{sample_weights.max()}')
 
-        # === Normalize and apply max_allowed_ratio ===
-        sample_weights = bittensor.utils.weight_utils.normalize_max_multiple(x=sample_weights,
-                                                                             multiple=max_allowed_ratio)
-        logger.info(f'{len(sample_weights)} normalize_max_multiple | '
-                    f'min:{sample_weights.min()} max:{sample_weights.max()}')
+        # === Normalize and apply max_weight_limit ===
+        sample_weights = bittensor.utils.weight_utils.normalize_max_weight(x=sample_weights,
+                                                                             limit=max_weight_limit)
+        logger.info(f'{len(sample_weights)} normalize_max_weight | '
+                    f'max:{sample_weights.max()}')
 
         return sample_uids, sample_weights
 
     def weights_table(self, sample_uids, sample_weights, include_uids=None, num_rows: int = None):
         r""" Prints weights table given sample_uids and sample_weights.
         """
         min_allowed_weights = self.subtensor.min_allowed_weights
-        max_allowed_ratio = self.subtensor.max_allowed_min_max_ratio
+        max_weight_limit = self.subtensor.max_weight_limit
 
         # === Weight table ===
         # Prints exponential moving average statistics of valid neurons and latest weights
@@ -763,8 +766,8 @@ def weights_table(self, sample_uids, sample_weights, include_uids=None, num_rows
                     f'sum:{sample_weights.sum().item():.2g} '
                     f'[white] max:[bold]{sample_weights.max().item():.4g}[/bold] / '
                     f'min:[bold]{sample_weights.min().item():.4g}[/bold] [/white] '
-                    f'\[{sample_weights.max().item() / sample_weights.min().item():.1f}:1] '
-                    f'({max_allowed_ratio} allowed)',  # caption
+                    f'\[{sample_weights.max().item()}:1] '
+                    f'({max_weight_limit} allowed)',  # caption
                     mark_uids=avail_include_uids)
 
 
@@ -774,6 +777,10 @@ class nucleus( torch.nn.Module ):
     def __init__( self, config, device, subtensor ):
         super(nucleus, self).__init__()
         self.config = config
+
+        self.config.nucleus.scaling_law_power = subtensor.scaling_law_power if self.config.nucleus.scaling_law_power == -1 else self.config.nucleus.scaling_law_power
+        self.config.nucleus.synergy_scaling_law_power = subtensor.synergy_scaling_law_power if self.config.nucleus.synergy_scaling_law_power == -1 else self.config.nucleus.synergy_scaling_law_power
+
         self.device = device
         self.max_n = subtensor.max_n
         self.permute_uids = []  # iterable of next UIDs to query, reset to permuted UIDs when empty
@@ -818,8 +825,8 @@ def add_args( cls, parser ):
         parser.add_argument('--nucleus.importance', type=float, help='hyperparameter for the importance loss', default=3)
         parser.add_argument('--nucleus.noise_multiplier', type=float, help='Standard deviation multipler on weights', default=2 )
         parser.add_argument('--nucleus.dendrite_backward', action='store_true', help='Pass backward request to the server side or not', default=False )
-        parser.add_argument('--nucleus.scaling_law_power', type=float, help='Power for modified scaling law, powered down to improve dynamic range, e.g. 3 → 6 nats for 0.5.', default=0.5)
-        parser.add_argument('--nucleus.synergy_scaling_law_power', type=float, help='Power for synergy modified scaling law, powered down to improve dynamic range, e.g. 3 → 6 nats for 0.5.', default=0.6)
+        parser.add_argument('--nucleus.scaling_law_power', type=float, help='Power for modified scaling law, powered down to improve dynamic range, e.g. 3 → 6 nats for 0.5. (default value: -1, pulling from subtensor directly)', default=-1)
+        parser.add_argument('--nucleus.synergy_scaling_law_power', type=float, help='Power for synergy modified scaling law, powered down to improve dynamic range, e.g. 3 → 6 nats for 0.5. (default value: -1, pulling from subtensor directly)', default=-1)
 
     @classmethod
     def config ( cls ):

bittensor/_subtensor/subtensor_impl.py

@@ -144,7 +144,7 @@ def rho (self) -> int:
         @retry(delay=2, tries=3, backoff=2, max_delay=4)
         def make_substrate_call_with_retry():
             with self.substrate as substrate:
-                return substrate.query(  module='SubtensorModule', storage_function = 'Rho').value
+                return substrate.query( module='SubtensorModule', storage_function = 'Rho' ).value
         return make_substrate_call_with_retry()
 
     @property
@@ -157,7 +157,7 @@ def kappa (self) -> int:
         @retry(delay=2, tries=3, backoff=2, max_delay=4)
         def make_substrate_call_with_retry():
             with self.substrate as substrate:
-                return substrate.query(  module='SubtensorModule', storage_function = 'Kappa').value
+                return substrate.query( module='SubtensorModule', storage_function = 'Kappa' ).value
         return make_substrate_call_with_retry()
 
     @property
@@ -170,7 +170,7 @@ def difficulty (self) -> int:
         @retry(delay=2, tries=3, backoff=2, max_delay=4)
         def make_substrate_call_with_retry():
             with self.substrate as substrate:
-                return substrate.query(  module='SubtensorModule', storage_function = 'Difficulty').value
+                return substrate.query( module='SubtensorModule', storage_function = 'Difficulty' ).value
         return make_substrate_call_with_retry()
 
     @property
@@ -196,7 +196,7 @@ def immunity_period (self) -> int:
         @retry(delay=2, tries=3, backoff=2, max_delay=4)
         def make_substrate_call_with_retry():
             with self.substrate as substrate:
-                return substrate.query(  module='SubtensorModule', storage_function = 'ImmunityPeriod').value
+                return substrate.query( module='SubtensorModule', storage_function = 'ImmunityPeriod' ).value
         return make_substrate_call_with_retry()
 
     @property
@@ -209,7 +209,7 @@ def validator_batch_size (self) -> int:
         @retry(delay=2, tries=3, backoff=2, max_delay=4)
         def make_substrate_call_with_retry():
             with self.substrate as substrate:
-                return substrate.query(  module='SubtensorModule', storage_function = 'ValidatorBatchSize').value
+                return substrate.query( module='SubtensorModule', storage_function = 'ValidatorBatchSize' ).value
         return make_substrate_call_with_retry()
 
 
@@ -223,7 +223,7 @@ def validator_sequence_length (self) -> int:
         @retry(delay=2, tries=3, backoff=2, max_delay=4)
         def make_substrate_call_with_retry():
             with self.substrate as substrate:
-                return substrate.query(  module='SubtensorModule', storage_function = 'ValidatorSequenceLength').value
+                return substrate.query( module='SubtensorModule', storage_function = 'ValidatorSequenceLength' ).value
         return make_substrate_call_with_retry()
 
     @property
@@ -236,7 +236,7 @@ def validator_epochs_per_reset (self) -> int:
         @retry(delay=2, tries=3, backoff=2, max_delay=4)
         def make_substrate_call_with_retry():
             with self.substrate as substrate:
-                return substrate.query(  module='SubtensorModule', storage_function = 'ValidatorEpochsPerReset').value
+                return substrate.query( module='SubtensorModule', storage_function = 'ValidatorEpochsPerReset' ).value
         return make_substrate_call_with_retry()
 
     @property
@@ -249,7 +249,7 @@ def validator_epoch_length (self) -> int:
         @retry(delay=2, tries=3, backoff=2, max_delay=4)
         def make_substrate_call_with_retry():
             with self.substrate as substrate:
-                return substrate.query(  module='SubtensorModule', storage_function = 'ValidatorEpochLen').value
+                return substrate.query( module='SubtensorModule', storage_function = 'ValidatorEpochLen' ).value
         return make_substrate_call_with_retry()
 
     @property
@@ -262,7 +262,7 @@ def total_stake (self) -> 'bittensor.Balance':
         @retry(delay=2, tries=3, backoff=2, max_delay=4)
         def make_substrate_call_with_retry():
             with self.substrate as substrate:
-                return bittensor.Balance.from_rao( substrate.query(  module='SubtensorModule', storage_function = 'TotalStake').value )
+                return bittensor.Balance.from_rao( substrate.query(  module='SubtensorModule', storage_function = 'TotalStake' ).value )
         return make_substrate_call_with_retry()
 
     @property
@@ -275,7 +275,63 @@ def min_allowed_weights (self) -> int:
         @retry(delay=2, tries=3, backoff=2, max_delay=4)
         def make_substrate_call_with_retry():
             with self.substrate as substrate:
-                return substrate.query(  module='SubtensorModule', storage_function = 'MinAllowedWeights').value
+                return substrate.query( module='SubtensorModule', storage_function = 'MinAllowedWeights' ).value
+        return make_substrate_call_with_retry()
+
+    @property
+    def max_weight_limit (self) -> int:
+        r""" Returns MaxWeightLimit
+        Returns:
+            max_weight (int):
+                the max value for weights after normalizaiton
+        """
+        @retry(delay=2, tries=3, backoff=2, max_delay=4)
+        def make_substrate_call_with_retry():
+            with self.substrate as substrate:
+                U32_MAX = 4294967295
+                return substrate.query( module='SubtensorModule', storage_function = 'MaxWeightLimit' ).value/U32_MAX
+        return make_substrate_call_with_retry()
+
+    @property
+    def scaling_law_power (self) -> int:
+        r""" Returns ScalingLawPower
+        Returns:
+            ScalingLawPower (float):
+                the power term attached to scaling law
+        """
+        @retry(delay=2, tries=3, backoff=2, max_delay=4)
+        def make_substrate_call_with_retry():
+            with self.substrate as substrate:
+                MAX = 100
+                return substrate.query( module='SubtensorModule', storage_function = 'ScalingLawPower' ).value/MAX
+        return make_substrate_call_with_retry()
+
+    @property
+    def synergy_scaling_law_power (self) -> int:
+        r""" Returns SynergyScalingLawPower
+        Returns:
+            SynergyScalingLawPower (float):
+                the term attached to synergy calculation during shapley scores
+        """
+        @retry(delay=2, tries=3, backoff=2, max_delay=4)
+        def make_substrate_call_with_retry():
+            with self.substrate as substrate:
+                MAX = 100
+                return substrate.query( module='SubtensorModule', storage_function = 'SynergyScalingLawPower' ).value/MAX
+        return make_substrate_call_with_retry()
+
+    @property
+    def validator_exclude_quantile (self) -> int:
+        r""" Returns ValidatorExcludeQuantile
+        Returns:
+            ValidatorExcludeQuantile (float):
+                the quantile that validators should exclude when setting their weights
+        """
+        @retry(delay=2, tries=3, backoff=2, max_delay=4)
+        def make_substrate_call_with_retry():
+            with self.substrate as substrate:
+                MAX = 100
+                return substrate.query( module='SubtensorModule', storage_function = 'ValidatorExcludeQuantile' ).value/MAX
         return make_substrate_call_with_retry()
 
     @property
@@ -288,7 +344,7 @@ def max_allowed_min_max_ratio(self) -> int:
         @retry(delay=2, tries=3, backoff=2, max_delay=4)
         def make_substrate_call_with_retry():
             with self.substrate as substrate:
-                return substrate.query(  module='SubtensorModule', storage_function = 'MaxAllowedMaxMinRatio').value
+                return substrate.query( module='SubtensorModule', storage_function = 'MaxAllowedMaxMinRatio' ).value
         return make_substrate_call_with_retry()
 
     @property
@@ -301,7 +357,7 @@ def n (self) -> int:
         @retry(delay=2, tries=3, backoff=2, max_delay=4)
         def make_substrate_call_with_retry():
             with self.substrate as substrate:
-                return substrate.query(  module='SubtensorModule', storage_function = 'N').value
+                return substrate.query( module='SubtensorModule', storage_function = 'N' ).value
         return make_substrate_call_with_retry()
 
     @property
@@ -314,7 +370,7 @@ def max_n (self) -> int:
         @retry(delay=2, tries=3, backoff=2, max_delay=4)
         def make_substrate_call_with_retry():
             with self.substrate as substrate:
-                return substrate.query(  module='SubtensorModule', storage_function = 'MaxAllowedUids').value
+                return substrate.query( module='SubtensorModule', storage_function = 'MaxAllowedUids' ).value
         return make_substrate_call_with_retry()
 
     @property
@@ -336,7 +392,7 @@ def blocks_since_epoch (self) -> int:
         @retry(delay=2, tries=3, backoff=2, max_delay=4)
         def make_substrate_call_with_retry():
             with self.substrate as substrate:
-                return substrate.query(  module='SubtensorModule', storage_function = 'BlocksSinceLastStep').value
+                return substrate.query( module='SubtensorModule', storage_function = 'BlocksSinceLastStep' ).value
         return make_substrate_call_with_retry()
 
     @property
@@ -349,7 +405,7 @@ def blocks_per_epoch (self) -> int:
         @retry(delay=2, tries=3, backoff=2, max_delay=4)
         def make_substrate_call_with_retry():
             with self.substrate as substrate:
-                return substrate.query(  module='SubtensorModule', storage_function = 'BlocksPerStep').value
+                return substrate.query( module='SubtensorModule', storage_function = 'BlocksPerStep' ).value
         return make_substrate_call_with_retry()
 
     def get_n (self, block: int = None) -> int: