refactor alpha values

Author: andreea-popescu-reef

pallets/subtensor/src/epoch/math.rs

@@ -1083,66 +1083,6 @@ pub fn hadamard_sparse(
     result
 }
 
-// Return matrix exponential moving average: `alpha * a_ij + one_minus_alpha * b_ij`.
-// `alpha` is the EMA coefficient, how much to add of the new observation, typically small,
-// higher alpha discounts older observations faster.
-#[allow(dead_code)]
-pub fn mat_ema(new: &[Vec<I32F32>], old: &[Vec<I32F32>], alpha: I32F32) -> Vec<Vec<I32F32>> {
-    let Some(first_row) = new.first() else {
-        return vec![vec![]];
-    };
-    if first_row.is_empty() {
-        return vec![vec![]; 1];
-    }
-    let one_minus_alpha: I32F32 = I32F32::from_num(1.0).saturating_sub(alpha);
-    new.iter()
-        .zip(old)
-        .map(|(new_row, old_row)| {
-            new_row
-                .iter()
-                .zip(old_row)
-                .map(|(new_elem, old_elem)| {
-                    alpha
-                        .saturating_mul(*new_elem)
-                        .saturating_add(one_minus_alpha.saturating_mul(*old_elem))
-                })
-                .collect()
-        })
-        .collect()
-}
-
-// Return sparse matrix exponential moving average: `alpha * a_ij + one_minus_alpha * b_ij`.
-// `alpha` is the EMA coefficient, how much to add of the new observation, typically small,
-// higher alpha discounts older observations faster.
-#[allow(dead_code, clippy::indexing_slicing)]
-pub fn mat_ema_sparse(
-    new: &[Vec<(u16, I32F32)>],
-    old: &[Vec<(u16, I32F32)>],
-    alpha: I32F32,
-) -> Vec<Vec<(u16, I32F32)>> {
-    assert!(new.len() == old.len());
-    let n = new.len(); // assume square matrix, rows=cols
-    let zero: I32F32 = I32F32::from_num(0.0);
-    let one_minus_alpha: I32F32 = I32F32::from_num(1.0).saturating_sub(alpha);
-    let mut result: Vec<Vec<(u16, I32F32)>> = vec![vec![]; n];
-    for i in 0..new.len() {
-        let mut row: Vec<I32F32> = vec![zero; n];
-        for (j, value) in new[i].iter() {
-            row[*j as usize] = row[*j as usize].saturating_add(alpha.saturating_mul(*value));
-        }
-        for (j, value) in old[i].iter() {
-            row[*j as usize] =
-                row[*j as usize].saturating_add(one_minus_alpha.saturating_mul(*value));
-        }
-        for (j, value) in row.iter().enumerate() {
-            if *value > zero {
-                result[i].push((j as u16, *value))
-            }
-        }
-    }
-    result
-}
-
 // Return sparse matrix only with elements >= threshold of an input sparse matrix.
 #[allow(dead_code)]
 pub fn sparse_threshold(w: &[Vec<(u16, I32F32)>], threshold: I32F32) -> Vec<Vec<(u16, I32F32)>> {
@@ -1157,6 +1097,10 @@ pub fn sparse_threshold(w: &[Vec<(u16, I32F32)>], threshold: I32F32) -> Vec<Vec<
 }
 
 /// Calculates the exponential moving average (EMA) for a sparse matrix using dynamic alpha values.
+/// Return matrix exponential moving average: `alpha_j * a_ij + one_minus_alpha_j * b_ij`.
+// `alpha` is the EMA coefficient, how much to add of the new observation, typically small,
+// higher alpha discounts older observations faster.
+// if liquid alpha off then the alpha vector will be constant
 #[allow(dead_code)]
 pub fn mat_ema_alpha_vec_sparse(
     new: &[Vec<(u16, I32F32)>],
@@ -1244,6 +1188,7 @@ pub fn mat_ema_alpha_vec_sparse(
 
 /// Return matrix exponential moving average: `alpha_j * a_ij + one_minus_alpha_j * b_ij`.
 /// `alpha_` is the EMA coefficient passed as a vector per column.
+// if liquid alpha off then the alpha vector will be constant
 #[allow(dead_code)]
 pub fn mat_ema_alpha_vec(
     new: &[Vec<I32F32>],
@@ -1265,7 +1210,6 @@ pub fn mat_ema_alpha_vec(
 
     // Iterate over each row of the matrices.
     for (i, (new_row, old_row)) in new.iter().zip(old).enumerate() {
-        // Ensure the current row of the new and old matrices have the same length.
         assert!(new_row.len() == old_row.len());
 
         // Iterate over each column of the current row.

pallets/subtensor/src/epoch/run_epoch.rs

@@ -167,18 +167,11 @@ impl<T: Config> Pallet<T> {
         inplace_col_normalize(&mut bonds); // sum_i b_ij = 1
         log::trace!("B:\n{:?}\n", &bonds);
 
+        // Get alpha values
+        let alpha = Self::compute_liquid_alpha(netuid, consensus.clone());
+
         // Compute the Exponential Moving Average (EMA) of bonds.
-        // Check if Liquid Alpha is enabled, consensus is not empty, and contains non-zero values.
-        let mut ema_bonds = if let Some(clamped_bonds_alpha) =
-            Self::compute_liquid_alpha(netuid, consensus.clone())
-        {
-            // Compute the Exponential Moving Average (EMA) of bonds using the clamped alpha values.
-            Self::compute_ema_bonds_with_liquid_alpha(&weights.clone(), &bonds, clamped_bonds_alpha)
-        } else {
-            log::trace!("Using Bonds Moving Average");
-            // Compute the EMA of bonds using a normal alpha value.
-            Self::compute_ema_bonds_normal(&weights.clone(), &bonds, netuid)
-        };
+        let mut ema_bonds = Self::compute_ema_bonds(&weights.clone(), &bonds, alpha);
         // Normalize EMA bonds.
         inplace_col_normalize(&mut ema_bonds); // sum_i b_ij = 1
         log::trace!("emaB:\n{:?}\n", &ema_bonds);
@@ -530,22 +523,11 @@ impl<T: Config> Pallet<T> {
         inplace_col_normalize_sparse(&mut bonds, n);
         log::trace!("B (mask+norm): {:?}", &bonds);
 
-        // Compute the Exponential Moving Average (EMA) of bonds.
-        let mut ema_bonds = if let Some(clamped_bonds_alpha) =
-            Self::compute_liquid_alpha(netuid, consensus.clone())
-        {
-            // Compute the Exponential Moving Average (EMA) of bonds using the clamped alpha values.
-            Self::compute_ema_bonds_with_liquid_alpha_sparse(
-                &weights.clone(),
-                &bonds,
-                clamped_bonds_alpha,
-            )
-        } else {
-            log::trace!("Using Bonds Moving Average");
-            // Compute the EMA of bonds using a normal alpha value.
-            Self::compute_ema_bonds_normal_sparse(&weights.clone(), &bonds, netuid)
-        };
+        // Get alpha values
+        let alpha = Self::compute_liquid_alpha(netuid, consensus.clone());
 
+        // Compute the Exponential Moving Average (EMA) of bonds.
+        let mut ema_bonds = Self::compute_ema_bonds_sparse(&weights.clone(), &bonds, alpha);
         // Normalize EMA bonds.
         inplace_col_normalize_sparse(&mut ema_bonds, n); // sum_i b_ij = 1
         log::trace!("Exponential Moving Average Bonds: {:?}", &ema_bonds);
@@ -937,16 +919,16 @@ impl<T: Config> Pallet<T> {
         clamped_alpha
     }
 
-    /// Compute the Exponential Moving Average (EMA) of bonds using the clamped alpha values for a sparse matrix.
+    /// Compute the Exponential Moving Average (EMA) of bonds using the alpha values for a sparse matrix.
     ///
     /// # Args:
     /// * `bonds_delta` - A vector of bond deltas.
     /// * `bonds` - A vector of bonds.
-    /// * `alpha` - A vector of clamped alpha values.
+    /// * `alpha` - A vector of clamped alpha values (for liquid alpha) or constant alpha values.
     ///
     /// # Returns:
     /// A vector of EMA bonds.
-    pub fn compute_ema_bonds_with_liquid_alpha_sparse(
+    pub fn compute_ema_bonds_sparse(
         bonds_delta: &[Vec<(u16, I32F32)>],
         bonds: &[Vec<(u16, I32F32)>],
         alpha: Vec<I32F32>,
@@ -955,25 +937,22 @@ impl<T: Config> Pallet<T> {
         let ema_bonds = mat_ema_alpha_vec_sparse(bonds_delta, bonds, &alpha);
 
         // Log the computed EMA bonds for debugging purposes.
-        log::trace!(
-            "Exponential Moving Average Bonds Liquid Alpha: {:?}",
-            ema_bonds
-        );
+        log::trace!("Exponential Moving Average Bonds: {:?}", ema_bonds);
 
         // Return the computed EMA bonds.
         ema_bonds
     }
 
-    /// Compute the Exponential Moving Average (EMA) of bonds using the clamped alpha values.
+    /// Compute the Exponential Moving Average (EMA) of bonds using the alpha values.
     ///
     /// # Args:
     /// * `bonds_delta` - A vector of bond deltas.
     /// * `bonds` - A vector of bonds.
-    /// * `alpha` - A vector of clamped alpha values.
+    /// * `alpha` - A vector of clamped alpha values (for liquid alpha) or constant alpha values.
     ///
     /// # Returns:
     /// A vector of EMA bonds.
-    pub fn compute_ema_bonds_with_liquid_alpha(
+    pub fn compute_ema_bonds(
         bonds_delta: &[Vec<I32F32>],
         bonds: &[Vec<I32F32>],
         alpha: Vec<I32F32>,
@@ -982,76 +961,7 @@ impl<T: Config> Pallet<T> {
         let ema_bonds = mat_ema_alpha_vec(bonds_delta, bonds, &alpha);
 
         // Log the computed EMA bonds for debugging purposes.
-        log::trace!(
-            "Exponential Moving Average Bonds Liquid Alpha: {:?}",
-            ema_bonds
-        );
-
-        // Return the computed EMA bonds.
-        ema_bonds
-    }
-
-    /// Compute the Exponential Moving Average (EMA) of bonds using a normal alpha value for a sparse matrix.
-    ///
-    /// # Args:
-    /// * `bonds_delta` - A vector of bond deltas.
-    /// * `bonds` - A vector of bonds.
-    /// * `netuid` - The network ID.
-    ///
-    /// # Returns:
-    /// A vector of EMA bonds.
-    pub fn compute_ema_bonds_normal_sparse(
-        bonds_delta: &[Vec<(u16, I32F32)>],
-        bonds: &[Vec<(u16, I32F32)>],
-        netuid: u16,
-    ) -> Vec<Vec<(u16, I32F32)>> {
-        // Retrieve the bonds moving average for the given network ID and scale it down.
-        let bonds_moving_average: I64F64 = I64F64::from_num(Self::get_bonds_moving_average(netuid))
-            .saturating_div(I64F64::from_num(1_000_000));
-
-        // Calculate the alpha value for the EMA calculation.
-        // Alpha is derived by subtracting the scaled bonds moving average from 1.
-        let alpha: I32F32 =
-            I32F32::from_num(1).saturating_sub(I32F32::from_num(bonds_moving_average));
-
-        // Compute the Exponential Moving Average (EMA) of bonds using the calculated alpha value.
-        let ema_bonds = mat_ema_sparse(bonds_delta, bonds, alpha);
-
-        // Log the computed EMA bonds for debugging purposes.
-        log::trace!("Exponential Moving Average Bonds Normal: {:?}", ema_bonds);
-
-        // Return the computed EMA bonds.
-        ema_bonds
-    }
-
-    /// Compute the Exponential Moving Average (EMA) of bonds using a normal alpha value.
-    ///
-    /// # Args:
-    /// * `bonds_delta` - A vector of bond deltas.
-    /// * `bonds` - A vector of bonds.
-    /// * `netuid` - The network ID.
-    ///
-    /// # Returns:
-    /// A vector of EMA bonds.
-    pub fn compute_ema_bonds_normal(
-        bonds_delta: &[Vec<I32F32>],
-        bonds: &[Vec<I32F32>],
-        netuid: u16,
-    ) -> Vec<Vec<I32F32>> {
-        // Retrieve the bonds moving average for the given network ID and scale it down.
-        let bonds_moving_average: I64F64 = I64F64::from_num(Self::get_bonds_moving_average(netuid))
-            .saturating_div(I64F64::from_num(1_000_000));
-
-        // Calculate the alpha value for the EMA calculation.
-        // Alpha is derived by subtracting the scaled bonds moving average from 1.
-        let alpha: I32F32 =
-            I32F32::from_num(1).saturating_sub(I32F32::from_num(bonds_moving_average));
-
-        // Compute the Exponential Moving Average (EMA) of bonds using the calculated alpha value.
-        let ema_bonds = mat_ema(bonds_delta, bonds, alpha);
-
-        // Log the computed EMA bonds for debugging purposes.
-        log::trace!("Exponential Moving Average Bonds Normal: {:?}", ema_bonds);
+        log::trace!("Exponential Moving Average Bonds: {:?}", ema_bonds);
 
         // Return the computed EMA bonds.
         ema_bonds
@@ -1065,7 +975,7 @@ impl<T: Config> Pallet<T> {
     ///
     /// # Returns:
     /// A vector of alphas
-    pub fn compute_liquid_alpha(netuid: u16, consensus: Vec<I32F32>) -> Option<Vec<I32F32>> {
+    pub fn compute_liquid_alpha(netuid: u16, consensus: Vec<I32F32>) -> Vec<I32F32> {
         // Check if Liquid Alpha is enabled, consensus is not empty, and contains non-zero values.
         if LiquidAlphaOn::<T>::get(netuid)
             && !consensus.is_empty()
@@ -1092,15 +1002,30 @@ impl<T: Config> Pallet<T> {
                 );
 
                 // Compute the alpha values using the logistic function parameters.
+                // alpha = 1 / (1 + math.e ** (-a * C + b))  # alpha to the old weight
                 let alpha = Self::compute_alpha_values(&consensus, a, b);
 
                 // Clamp the alpha values between alpha_high and alpha_low.
                 let clamped_alpha = Self::clamp_alpha_values(alpha, alpha_high, alpha_low);
 
-                return Some(clamped_alpha);
+                return clamped_alpha;
             }
         }
-        None
+
+        // Liquid Alpha is disabled
+        // or high and low consensus values do not meet the required conditions.
+        // return vector of constant alpha
+
+        // Retrieve the bonds moving average for the given network ID and scale it down.
+        let bonds_moving_average: I64F64 = I64F64::from_num(Self::get_bonds_moving_average(netuid))
+            .saturating_div(I64F64::from_num(1_000_000));
+
+        // Calculate the alpha value for the EMA calculation.
+        // Alpha is derived by subtracting the scaled bonds moving average from 1.
+        let alpha: I32F32 =
+            I32F32::from_num(1).saturating_sub(I32F32::from_num(bonds_moving_average));
+
+        vec![alpha; consensus.len()]
     }
 
     pub fn do_set_alpha_values(

pallets/subtensor/src/tests/epoch.rs

@@ -2513,7 +2513,7 @@ fn test_calculate_logistic_params_edge_cases() {
 }
 
 #[test]
-fn test_compute_ema_bonds_with_liquid_alpha_sparse() {
+fn test_compute_ema_bonds_sparse() {
     // Define test inputs
     let bonds_delta = vec![
         vec![(0, I32F32::from_num(0.1)), (1, I32F32::from_num(0.2))],
@@ -2542,16 +2542,15 @@ fn test_compute_ema_bonds_with_liquid_alpha_sparse() {
     ];
 
     // Call the function
-    let ema_bonds =
-        SubtensorModule::compute_ema_bonds_with_liquid_alpha_sparse(&bonds_delta, &bonds, alpha);
+    let ema_bonds = SubtensorModule::compute_ema_bonds_sparse(&bonds_delta, &bonds, alpha);
 
     // Assert the results with an epsilon for approximate equality
     let epsilon = I32F32::from_num(1e-6);
     assert_approx_eq_vec_of_vec(&ema_bonds, &expected_ema_bonds, epsilon);
 }
 
 #[test]
-fn test_compute_ema_bonds_with_liquid_alpha_sparse_empty() {
+fn test_compute_ema_bonds_sparse_empty() {
     // Test with empty inputs
     let bonds_delta: Vec<Vec<(u16, I32F32)>> = vec![];
     let bonds: Vec<Vec<(u16, I32F32)>> = vec![];
@@ -2561,8 +2560,7 @@ fn test_compute_ema_bonds_with_liquid_alpha_sparse_empty() {
     let expected_ema_bonds: Vec<Vec<(u16, I32F32)>> = vec![];
 
     // Call the function
-    let ema_bonds =
-        SubtensorModule::compute_ema_bonds_with_liquid_alpha_sparse(&bonds_delta, &bonds, alpha);
+    let ema_bonds = SubtensorModule::compute_ema_bonds_sparse(&bonds_delta, &bonds, alpha);
 
     // Assert the results
     assert_eq!(