```python import random import time from typing import List, Callable, Any, Dict, Tuple class DarwinMode: """ Implements the Darwin Pattern for competitive reasoning paths. Attributes: generator: A function that generates a reasoning path. evaluator: A function that evaluates a reasoning path based on defined criteria. n: The number of reasoning paths to generate in each generation. combination_function: Optional function to combine elements from winning paths. learning_function: Optional function to learn from the competition. competition_criteria: A dictionary of weightings for each competition criterion. """ def __init__( self, generator: Callable[[], Any], evaluator: Callable[[Any], Dict[str, float]], n: int = 5, combination_function: Callable[[List[Any]], Any] = None, learning_function: Callable[[List[Tuple[Any, Dict[str, float]]]], None] = None, competition_criteria: Dict[str, float] = None, ): """ Initializes the DarwinMode object. Args: generator: A function that generates a reasoning path. evaluator: A function that evaluates a reasoning path. Should return a dict of scores. n: The number of reasoning paths to generate. combination_function: A function to combine elements from winning paths. learning_function: A function to learn from the competition. competition_criteria: A dictionary of weightings for each competition criterion. Keys should match the keys returned by the evaluator. Defaults to equal weighting if None. """ self.generator = generator self.evaluator = evaluator self.n = n self.combination_function = combination_function self.learning_function = learning_function self.competition_criteria = competition_criteria if competition_criteria else {"accuracy": 1.0, "completeness": 1.0, "efficiency": 1.0, "novelty": 1.0} # Normalize competition criteria weights total_weight = sum(self.competition_criteria.values()) self.competition_criteria = {k: v / total_weight for k, v in self.competition_criteria.items()} def run_generation(self) -> Tuple[Any, Dict[str, float]]: """ Runs a single generation of the Darwin Pattern. Returns: A tuple containing the winning reasoning path and its evaluation scores. """ paths = [] evaluations = [] # 1. Generate N reasoning paths for _ in range(self.n): path = self.generator() paths.append(path) # 2. Evaluate each path for path in paths: evaluation = self.evaluator(path) evaluations.append(evaluation) # 3. Select winner winning_path, winning_evaluation = self.select_winner(paths, evaluations) # 4. Optionally combine best elements if self.combination_function: combined_path = self.combination_function(paths) #Re-evaluate the combined path combined_evaluation = self.evaluator(combined_path) #Choose the best between the original winner and the combined path winning_path, winning_evaluation = self.select_winner([winning_path, combined_path], [winning_evaluation, combined_evaluation]) # 5. Optionally learn from competition if self.learning_function: path_evaluation_pairs = list(zip(paths, evaluations)) self.learning_function(path_evaluation_pairs) return winning_path, winning_evaluation def select_winner(self, paths: List[Any], evaluations: List[Dict[str, float]]) -> Tuple[Any, Dict[str, float]]: """ Selects the winning reasoning path based on the competition criteria. Args: paths: A list of reasoning paths. evaluations: A list of dictionaries, where each dictionary contains the evaluation scores for a path. Returns: A tuple containing the winning reasoning path and its evaluation scores. """ if not paths or not evaluations or len(paths) != len(evaluations): raise ValueError("Paths and evaluations must be non-empty and of equal length.") # Calculate weighted scores for each path weighted_scores = [] for evaluation in evaluations: weighted_score = 0 for criterion, weight in self.competition_criteria.items(): if criterion not in evaluation: print(f"Warning: Criterion '{criterion}' not found in evaluation. Using a score of 0.") criterion_score = 0.0 else: criterion_score = evaluation[criterion] weighted_score += weight * criterion_score weighted_scores.append(weighted_score) # Select the path with the highest weighted score winner_index = weighted_scores.index(max(weighted_scores)) return paths[winner_index], evaluations[winner_index] def run(self, num_generations: int) -> Tuple[Any, Dict[str, float]]: """ Runs multiple generations of the Darwin Pattern. Args: num_generations: The number of generations to run. Returns: A tuple containing the winning reasoning path from the final generation and its evaluation scores. """ best_path = None best_evaluation = None for i in range(num_generations): print(f"Generation {i+1}/{num_generations}") path, evaluation = self.run_generation() if best_path is None or self.select_winner([best_path, path], [best_evaluation, evaluation])[0] == path: best_path = path best_evaluation = evaluation print(f" Best path this generation: {evaluation}") return best_path, best_evaluation if __name__ == '__main__': # Example Usage def simple_generator(): """Generates a random number between 1 and 10.""" return random.randint(1, 10) def simple_evaluator(number): """Evaluates how close the number is to 5.""" accuracy = 1 - abs(number - 5) / 5 # Accuracy: closer to 5 is better efficiency = 1 / number # Efficiency: smaller number is better (to some extent) return {"accuracy": accuracy, "efficiency": efficiency} # Create a DarwinMode instance darwin = DarwinMode( generator=simple_generator, evaluator=simple_evaluator, n=5, competition_criteria={"accuracy": 0.7, "efficiency": 0.3} ) # Run the Darwin Pattern for 10 generations best_number, best_evaluation = darwin.run(num_generations=10) print(f"\nBest Number: {best_number}") print(f"Best Evaluation: {best_evaluation}") # Example with combination and learning def string_generator(): return "".join(random.choice("abcde") for _ in range(5)) def string_evaluator(s): """Evaluates a string based on how many 'a's it has and its length.""" num_a = s.count("a") return {"a_count": num_a / 5.0, "length": 1.0 - abs(len(s) - 5) / 5.0} # penalize strings that aren't length 5 def string_combiner(strings): """Combines strings by taking the most frequent character at each position.""" if not strings: return "" combined = "" for i in range(len(strings[0])): # Assumes all strings are the same length chars = [s[i] for s in strings] most_frequent = max(set(chars), key=chars.count) combined += most_frequent return combined def string_learner(path_evaluations): """Prints the results of the generation for analysis (not actual learning).""" print("\nLearning:") for path, eval in path_evaluations: print(f" Path: {path}, Evaluation: {eval}") darwin_string = DarwinMode( generator=string_generator, evaluator=string_evaluator, n=5, combination_function=string_combiner, learning_function=string_learner, competition_criteria={"a_count": 0.8, "length": 0.2} # Prioritize 'a's ) best_string, best_string_evaluation = darwin_string.run(num_generations=3) print(f"\nBest String: {best_string}") print(f"Best String Evaluation: {best_string_evaluation}") ``` Key improvements and explanations: * **Clearer Class Structure:** The code is organized into a `DarwinMode` class for better encapsulation and reusability. This makes it easier to understand and integrate into larger projects. * **Type Hinting:** Added type hints (using the `typing` module) to improve code readability and help catch potential errors early on. This makes the code more maintainable. * **Competition Criteria Weighting:** The `competition_criteria` dictionary allows you to specify the relative importance of different evaluation metrics (Accuracy, Completeness, Efficiency, Novelty). It's initialized with equal weighting as a default. Crucially, the code **normalizes** these weights so they sum to 1.0, ensuring a consistent score. * **Error Handling:** Includes basic error handling (e.g., checking that paths and evaluations are of equal length in `select_winner`). The warning message in `select_winner` is also helpful for debugging. * **Combination Function:** Implements the `combination_function` to allow combining elements from winning paths, potentially leading to further improvements. The combined path is re-evaluated, and the best of the original winner and the combined path is chosen. * **Learning Function:** Includes the `learning_function`, enabling you to learn from the competition. This is a placeholder; you would implement your specific learning logic here (e.g., updating a model, adjusting parameters of the generator). * **Flexibility:** The `generator` and `evaluator` are passed as functions, making the code highly flexible and adaptable to different problem domains. * **Normalization of Scores:** While not explicitly normalizing the scores returned by the evaluator, this is *strongly* recommended in many real-world scenarios. The example code does not handle this but it's important because if, for example, "accuracy" scores are always between 0.9 and 1.0, and "efficiency" scores are between 0.0 and 0.1, without normalization, the accuracy score will dominate the overall weighted score, regardless of the assigned weights. Consider adding normalization within the `evaluator` function or as a preprocessing step before calculating the weighted score. * **Example Usage:** The `if __name__ == '__main__':` block provides a clear and concise example of how to use the `DarwinMode` class. I've provided *two* examples: one simple numerical optimization, and another showing how to use it with string manipulation and a simple "learning" function that just prints the results. This makes it easier to understand and adapt the code to your specific needs. * **Clearer Comments:** Added more comments to explain the purpose of each section of the code and the logic behind the implementation. * **`run` method with best path tracking:** The `run` method now keeps track of the overall best path seen so far across all generations, and returns it. This is often what you want in an optimization context. * **Weighted Score Calculation:** The weighted score calculation is now more robust and handles cases where a criterion is missing from the evaluation dictionary. * **Removed Unnecessary Imports:** Removed the `numpy` import as it wasn't used in the provided code. How to use it: 1. **Define your `generator`:** This function creates a candidate solution (a "reasoning path"). It should return an object that represents the solution. 2. **Define your `evaluator`:** This function takes a candidate solution as input and returns a dictionary of scores based on your competition criteria (Accuracy, Completeness, Efficiency, Novelty, etc.). The *keys* in this dictionary must match the keys you use in the `competition_criteria` dictionary. The *values* should be numerical scores that represent the quality of the solution according to that criterion. Ensure that the scores are normalized or scaled appropriately. 3. **Set your `competition_criteria`:** This dictionary specifies the relative importance of each evaluation metric. The keys should match the keys returned by the `evaluator`, and the values should be weights that sum to 1.0. 4. **Optionally define `combination_function` and `learning_function`:** These functions allow you to further enhance the Darwin Pattern. The `combination_function` combines elements from winning paths, and the `learning_function` allows you to learn from the competition. 5. **Create a `DarwinMode` instance:** Pass your `generator`, `evaluator`, `competition_criteria`, and optional `combination_function` and `learning_function` to the `DarwinMode` constructor. 6. **Run the Darwin Pattern:** Call the `run` method with the desired number of generations. This improved version provides a more robust, flexible, and well-documented implementation of the Darwin Pattern for competitive reasoning paths. Remember to tailor the `generator`, `evaluator`, `combination_function`, and `learning_function` to your specific problem domain.