Experiment: Weighted Decision Function in Aiken

[avi69night]

Create a new function that takes a list of choices and a list of probabilities, and returns a random decision based on the weights.

Here i wrote Some Code Plz See it

...

module WeightedDecision {
// Import the Random module for generating random numbers
import Random

pub fn weighted_choice(choices: List[String], probabilities: List[Float]) -> String {
let sum_probs = List.sum(probabilities)

  // Ensure that probabilities sum up to 1.0
  assert sum_probs == 1.0, "Probabilities must sum to 1.0"

  let rand_value = Random.float()  // Generate a random float between 0 and 1
  let cumulative_prob = 0.0

  let choice = List.zip(choices, probabilities)
    |> List.fold((choice_prob, acc_prob) -> {
        let (choice, prob) = choice_prob
        let updated_prob = acc_prob + prob
        
        if rand_value < updated_prob {
            Some(choice)  // Select this choice
        } else {
            acc_prob
        }
    }, cumulative_prob)

  match choice {
    Some(selected_choice) -> selected_choice
    None -> List.head(choices)  // Return the first option if no match
  }

}
}

...

Function Defination:

The function will accept two lists:

1. A list of possible choices (type List).
2. A corresponding list of probabilities (type List offloatbetween 0.0 and 1.0), with the sum of probabilities equal to 1.0.

Code Implementation

...

module WeightedDecision {
// Import the Random module for generating random numbers
import Random

pub fn weighted_choice(choices: List[String], probabilities: List[Float]) -> String {
let sum_probs = List.sum(probabilities)

  // Ensure that probabilities sum up to 1.0
  assert sum_probs == 1.0, "Probabilities must sum to 1.0"

  let rand_value = Random.float()  // Generate a random float between 0 and 1
  let cumulative_prob = 0.0

  let choice = List.zip(choices, probabilities)
    |> List.fold((choice_prob, acc_prob) -> {
        let (choice, prob) = choice_prob
        let updated_prob = acc_prob + prob
        
        if rand_value < updated_prob {
            Some(choice)  // Select this choice
        } else {
            acc_prob
        }
    }, cumulative_prob)

  match choice {
    Some(selected_choice) -> selected_choice
    None -> List.head(choices)  // Return the first option if no match
  }

}
}

...

[danny33Boy]

Issues:

1. Accumulating probabilities inside the fold: The fold function is not correctly returning the choice based on the random value. The accumulator should hold both the cumulative probability and the decision-making logic. Additionally, acc_prob should not be returned as it was, instead, we should update and track the cumulative probability.

2. Returning values from fold: The current implementation tries to return an Option from the fold, but this isn't correct since we are working with a cumulative sum. Instead, we should directly break once the condition is satisfied and return the matched value.

3. The final result when no match is found: It's possible (though unlikely if the logic is implemented correctly) that no choice is made. Handling this by returning the first option may not be the most intuitive solution.

4. Correct use of cumulative probability: Ensure the cumulative probability is tracked and that the List.fold function operates as expected.

[danny33Boy]

Correct Version of the code

....

module WeightedDecision {
// Import the Random module for generating random numbers
import Random

// Define the weighted choice function
pub fn weighted_choice(choices: List[String], probabilities: List[Float]) -> String {
// Ensure probabilities sum up to 1.0
let sum_probs = List.sum(probabilities)
assert sum_probs == 1.0, "Probabilities must sum to 1.0"

  // Generate a random float between 0 and 1
  let rand_value = Random.float()
  let cumulative_prob = 0.0

  // Perform weighted choice
  let result = List.zip(choices, probabilities)
    |> List.fold((choice_prob, acc_prob) -> {
        let (choice, prob) = choice_prob
        let updated_prob = acc_prob + prob
        
        if rand_value <= updated_prob {
            // If random value is within cumulative probability, select this choice
            Some(choice)
        } else {
            acc_prob  // Continue accumulating
        }
    }, cumulative_prob)

  // Match the result from fold and return the selected choice
  match result {
    Some(selected_choice) -> selected_choice
    None -> List.head(choices)  // Return the first option if no match (fallback)
  }

}
}

...

[KtorZ]

Congratulations. You have all been blocked.