Skip to content

BaseTask

evotoolkit.core.BaseTask

Bases: ABC

Abstract base class for evolutionary optimization tasks.

This class unifies the functionality of BaseEvaluator and BaseTaskConfig into a single concept, providing both evaluation capabilities and task configuration in one place.

Source code in src/evotoolkit/core/base_task.py 
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
class BaseTask(ABC):
    """
    Abstract base class for evolutionary optimization tasks.

    This class unifies the functionality of BaseEvaluator and BaseTaskConfig
    into a single concept, providing both evaluation capabilities and task
    configuration in one place.
    """

    def __init__(self, data):
        """
        Initialize the task with input data.

        Args:
            data (Any): Task-specific input data (format varies by task type).
        """
        self._process_data(data)

    def _process_data(self, data):
        """
        Process input data and set up task_info.

        This method should be overridden by subclasses to handle
        task-specific data processing and create the task_info dict.

        Args:
            data (Any): Task-specific input data.
        """
        self.data = data
        self.task_info = {}  # Subclasses should populate this

    # === Abstract methods from BaseEvaluator ===

    @abstractmethod
    def evaluate_code(self, candidate_code: str) -> EvaluationResult:
        """
        Evaluate a candidate code solution and return evaluation result.

        This is the simple interface for tasks that only need a code string.
        For tasks requiring additional information, override evaluate_solution().

        Args:
            candidate_code: The code to evaluate

        Returns:
            EvaluationResult: Result of the evaluation
        """
        pass

    def evaluate_solution(self, solution: Solution) -> EvaluationResult:
        """
        Evaluate a Solution object and return evaluation result.

        This method provides a richer interface for complex tasks that need
        additional information beyond just code. The Solution object can carry:
        - sol_string: The main code (e.g., kernel source)
        - other_info: Additional metadata (e.g., tiling config, block_dim)

        Default implementation simply calls evaluate_code(solution.sol_string).
        Complex tasks (e.g., CANN) should override this method to extract
        additional information from solution.other_info.

        Args:
            solution: Solution object containing code and optional metadata

        Returns:
            EvaluationResult: Result of the evaluation
        """
        return self.evaluate_code(solution.sol_string)

    # === Abstract methods from BaseTaskConfig ===

    @abstractmethod
    def get_base_task_description(self) -> str:
        """
        Get the base task description for prompt generation.

        Returns:
            str: Task description text
        """
        pass

    @abstractmethod
    def make_init_sol_wo_other_info(self) -> Solution:
        """
        Create initial solution from task info without other_info.

        Returns:
            Solution: Initial solution for this task
        """
        pass

    # === Optional methods that subclasses can override ===

    def get_task_type(self) -> str:
        """
        Get the type of this task (e.g., 'Python', 'Cuda').

        Default implementation returns 'Python'. Subclasses should
        override if they represent different task types.

        Returns:
            str: Task type identifier
        """
        return "Python"

    def get_task_info(self) -> dict:
        """
        Get the task_info dictionary.

        Returns:
            dict: Task information dictionary
        """
        return self.task_info

__init__ 

__init__(data)

Initialize the task with input data.

Parameters:

Name Type Description Default
data Any

Task-specific input data (format varies by task type).

 required
Source code in src/evotoolkit/core/base_task.py 
27
28
29
30
31
32
33
34
def __init__(self, data):
    """
    Initialize the task with input data.

    Args:
        data (Any): Task-specific input data (format varies by task type).
    """
    self._process_data(data)

evaluate_code abstractmethod 

evaluate_code(candidate_code: str) -> EvaluationResult

Evaluate a candidate code solution and return evaluation result.

This is the simple interface for tasks that only need a code string. For tasks requiring additional information, override evaluate_solution().

Parameters:

Name Type Description Default
candidate_code str

The code to evaluate

 required

Returns:

Name Type Description
EvaluationResult EvaluationResult

Result of the evaluation
Source code in src/evotoolkit/core/base_task.py 
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
@abstractmethod
def evaluate_code(self, candidate_code: str) -> EvaluationResult:
    """
    Evaluate a candidate code solution and return evaluation result.

    This is the simple interface for tasks that only need a code string.
    For tasks requiring additional information, override evaluate_solution().

    Args:
        candidate_code: The code to evaluate

    Returns:
        EvaluationResult: Result of the evaluation
    """
    pass

evaluate_solution 

evaluate_solution(solution: Solution) -> EvaluationResult

Evaluate a Solution object and return evaluation result.

This method provides a richer interface for complex tasks that need additional information beyond just code. The Solution object can carry: - sol_string: The main code (e.g., kernel source) - other_info: Additional metadata (e.g., tiling config, block_dim)

Default implementation simply calls evaluate_code(solution.sol_string). Complex tasks (e.g., CANN) should override this method to extract additional information from solution.other_info.

Parameters:

Name Type Description Default
solution Solution

Solution object containing code and optional metadata

 required

Returns:

Name Type Description
EvaluationResult EvaluationResult

Result of the evaluation
Source code in src/evotoolkit/core/base_task.py 
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
def evaluate_solution(self, solution: Solution) -> EvaluationResult:
    """
    Evaluate a Solution object and return evaluation result.

    This method provides a richer interface for complex tasks that need
    additional information beyond just code. The Solution object can carry:
    - sol_string: The main code (e.g., kernel source)
    - other_info: Additional metadata (e.g., tiling config, block_dim)

    Default implementation simply calls evaluate_code(solution.sol_string).
    Complex tasks (e.g., CANN) should override this method to extract
    additional information from solution.other_info.

    Args:
        solution: Solution object containing code and optional metadata

    Returns:
        EvaluationResult: Result of the evaluation
    """
    return self.evaluate_code(solution.sol_string)

get_base_task_description abstractmethod 

get_base_task_description() -> str

Get the base task description for prompt generation.

Returns:

Name Type Description
str str

Task description text
Source code in src/evotoolkit/core/base_task.py 
90
91
92
93
94
95
96
97
98
@abstractmethod
def get_base_task_description(self) -> str:
    """
    Get the base task description for prompt generation.

    Returns:
        str: Task description text
    """
    pass

make_init_sol_wo_other_info abstractmethod 

make_init_sol_wo_other_info() -> Solution

Create initial solution from task info without other_info.

Returns:

Name Type Description
Solution Solution

Initial solution for this task
Source code in src/evotoolkit/core/base_task.py 
100
101
102
103
104
105
106
107
108
@abstractmethod
def make_init_sol_wo_other_info(self) -> Solution:
    """
    Create initial solution from task info without other_info.

    Returns:
        Solution: Initial solution for this task
    """
    pass

get_task_type 

get_task_type() -> str

Get the type of this task (e.g., 'Python', 'Cuda').

Default implementation returns 'Python'. Subclasses should override if they represent different task types.

Returns:

Name Type Description
str str

Task type identifier
Source code in src/evotoolkit/core/base_task.py 
112
113
114
115
116
117
118
119
120
121
122
def get_task_type(self) -> str:
    """
    Get the type of this task (e.g., 'Python', 'Cuda').

    Default implementation returns 'Python'. Subclasses should
    override if they represent different task types.

    Returns:
        str: Task type identifier
    """
    return "Python"

get_task_info 

get_task_info() -> dict

Get the task_info dictionary.

Returns:

Name Type Description
dict dict

Task information dictionary
Source code in src/evotoolkit/core/base_task.py 
124
125
126
127
128
129
130
131
def get_task_info(self) -> dict:
    """
    Get the task_info dictionary.

    Returns:
        dict: Task information dictionary
    """
    return self.task_info

See the Custom Task Tutorial for a complete guide.