PyIAML 1.0.0__py3-none-any.whl

iaml/metrics/specificity_metric.py

@@ -0,0 +1,44 @@
+"""[METRIC] Specificity"""
+from typing import Any
+import textwrap
+import pandas as pd
+from sklearn.metrics import confusion_matrix
+from ..metric import Metric
+
+class SpecificityMetric(Metric):
+    """[METRIC] Specificity"""
+
+    name: str = "Specificity"
+    _description: str = textwrap.dedent('''\
+        Specificity is a metric used to evaluate the performance of a classification model. 
+        It measures the proportion of true negatives correctly identified by the model, indicating 
+        how well it can identify the negative class.''')
+    _description_long: str = textwrap.dedent('''\
+        Specificity is a metric that helps assess how well a classification model identifies the negative class. 
+        For example, if you're predicting whether a medical test result is negative for a disease, specificity tells you the 
+        percentage of actual negative cases that the model correctly identifies. A high specificity means the model is good at 
+        avoiding false positives, while a low specificity indicates it may incorrectly label negative cases as positive.
+        ''')
+    refs: list[dict[str, Any]]=[
+        {
+            'year': 1994 ,
+            'name': 'Diagnostic tests. 1: Sensitivity and specificity.',
+            'authors': [
+                'D. G. Altman',
+                'J. M. Bland'
+            ],
+            'doi': 'https://doi.org/10.1136%2Fbmj.308.6943.1552',
+            'publisher': 'BMJ. 308 (6943): 1552'
+        }
+    ]
+
+    def __str__(self) -> str:
+        return 'specificity'
+
+    def suitable(self, X: pd.DataFrame, y: pd.DataFrame, type_of_target: str) -> bool:
+        return type_of_target == 'binary'
+
+    def compute(self, y: pd.DataFrame, y_pred: pd.DataFrame, **kwargs) -> float:
+        tn, fp, _, _ = confusion_matrix(y, y_pred).ravel()
+
+        return tn / (tn + fp) if (tn + fp) != 0 else 0

iaml/metrics/specificity_multiclass_metric.py

@@ -0,0 +1,55 @@
+"""[METRIC] Specificity Multiclass"""
+from typing import Any
+import textwrap
+import pandas as pd
+from sklearn.metrics import confusion_matrix
+import numpy as np
+from ..metric import Metric
+
+
+class SpecificityMulticlassMetric(Metric):
+    """[METRIC] Specificity Multiclass"""
+
+    name: str = "Specificity Multiclass"
+    _description: str = textwrap.dedent('''\
+        Multiclass specificity is a metric used to evaluate the performance of a classification model
+        with multiple classes. It measures how well the model identifies the negative cases for each
+        class by considering true negatives and false positives.''')
+    _description_long: str = textwrap.dedent('''\
+        Multiclass specificity assesses how effectively a classification model identifies negative cases
+        across multiple classes. For each class, it calculates the number of true negatives (correctly 
+        identified negatives) and false positives (incorrectly identified positives). 
+        By summing these values for all classes, you can determine an overall specificity score. 
+        A high multiclass specificity indicates that the model is good at correctly identifying non-target classes, 
+        while a low score suggests it may struggle with misclassifying negative cases.''')
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 2020,
+            'name': 'Metrics for Multi-Class Classification: an Overview',
+            'authors': [
+                'Margherita Grandini',
+                'Enrico Bagli',
+                'Giorgio Visani'
+            ],
+            'doi': 'https://doi.org/10.48550/arXiv.2008.05756',
+            'publisher': ''
+        }
+    ]
+
+    def __str__(self) -> str:
+        return 'specificity_multiclass'
+
+    def suitable(self, X: pd.DataFrame, y: pd.DataFrame, type_of_target: str) -> bool:
+        return type_of_target == 'multiclass'
+
+    def compute(self, y: pd.DataFrame, y_pred: pd.DataFrame, **kwargs) -> float:
+        # Specificity is calculated by summing the true negartives and false
+        # positives for each class, then using these totals to obtain an overall specificity"
+        cm = confusion_matrix(y, y_pred)
+        total_tn = 0
+        total_fp = 0
+        for i in range(len(cm)):
+            total_tn += np.sum(cm) - np.sum(cm[i, :]) - np.sum(cm[:, i]) + cm[i, i]
+            total_fp += np.sum(cm[:, i]) - cm[i, i]
+
+        return total_tn / (total_tn + total_fp)

iaml/metrics/specificity_multilabel_metric.py

@@ -0,0 +1,60 @@
+"""[METRIC] Specificity Multilabel"""
+from typing import Any
+import textwrap
+import pandas as pd
+from sklearn.metrics import multilabel_confusion_matrix
+import numpy as np
+from ..metric import Metric
+
+
+class SpecificityMultilabelMetric(Metric):
+    """[METRIC] Specificity Multilabel"""
+
+    name: str = "Specificity Multilabel"
+    _description: str = textwrap.dedent('''\
+        Multilabel specificity is a metric used to evaluate the performance of a classification model that 
+        predicts multiple labels for each instance. It measures how well the model identifies negative cases 
+        for each label individually.''')
+    _description_long: str = textwrap.dedent('''\
+        Multilabel specificity assesses how effectively a classification model identifies negative cases for 
+        multiple labels. It calculates specificity for each label separately by determining the true negatives 
+        and false positives for that label. After calculating the specificity for all labels, these values are 
+        averaged to obtain an overall measure. A high multilabel specificity indicates that the model is good at 
+        correctly identifying non-target labels, while a low score suggests it may misclassify negative cases. 
+        In summary, multilabel specificity helps evaluate a model's ability to accurately recognize negative outcomes 
+        across various labels.''')
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 2021,
+            'name': 'Comprehensive Comparative Study of Multi-Label Classification Methods',
+            'authors': [
+                'Jasmin Bogatinovski', 
+                'Ljupčo Todorovski', 
+                'Sašo Džeroski', 
+                'Dragi Kocev',
+            ],
+            'doi': 'https://doi.org/10.48550/arXiv.2102.07113',
+            'publisher': ''
+        }
+    ]
+
+    def _str__(self) -> str:
+        return 'specificity_multilabel'
+
+    def suitable(self, X: pd.DataFrame, y: pd.DataFrame, type_of_target: str) -> bool:
+        return type_of_target in ['multilabel-indicator']
+
+    def compute(self, y: pd.DataFrame, y_pred: pd.DataFrame, **kwargs) -> float:
+        # Specificity is calculated for each label separately,
+        # then averaged to obtain an overall measure.
+        # Generates a series of confusion matrices,  one for each label
+        mcm = multilabel_confusion_matrix(y, y_pred)
+        specificity_per_label = []
+        for i in range(mcm.shape[0]):
+            tn, fp, _, _ = mcm[i].ravel()
+            specificity = tn / (tn + fp) if (tn + fp) != 0 else 0
+            specificity_per_label.append(specificity)
+
+        mean_specificity = np.mean(specificity_per_label)
+
+        return mean_specificity

iaml/optimizers/__init__.py

@@ -0,0 +1,5 @@
+"""All IAML optimizers"""
+from .optimizer import Optimizer
+from .genetic_optimizer import GeneticOptimizer
+from .bayesian_optimizer import BayesianOptimizer
+from .random_optimizer import RandomOptimizer

iaml/optimizers/bayesian_optimizer.py

@@ -0,0 +1,193 @@
+"""
+Bayesian Optimization-based Optimizer for IAML.
+Optimizer receives a pool of Candidates, optimizes parameters using a surrogate model,
+and returns a new pool of candidates.
+"""
+from copy import deepcopy
+import random
+import numpy as np
+from skopt import Optimizer
+from skopt.space import Real, Integer, Categorical
+from ..candidate import Candidate
+from .optimizer import Optimizer as BaseOptimizer
+from ..step import Step
+from ..logger import Logger
+
+class BayesianOptimizer(BaseOptimizer):
+    def __init__(self, duration: int = None, max_iterations=50):
+        """
+        Initialize the Bayesian Optimization-based Optimizer.
+        :param max_iterations: Number of optimization iterations.
+        """
+        self.max_iterations = max_iterations
+        self.ignored_configs: list[str] = {'random_state'}
+        self.current_iteration = 0
+        self.max_candidates = 40
+        self.skopt_optimizers = {}
+    
+    def _generate_structure_id(self, candidate):
+        """Generate a unique identifier for the candidate structure."""
+        return hash(tuple((step[0], tuple(sorted(step[1].configuration.keys()))) for step in candidate.pipeline.steps))
+    
+    def _initialize_search_space(self, candidates):
+        """Define the search space for each unique candidate structure."""
+        for candidate in candidates:
+            structure_id = self._generate_structure_id(candidate)
+            if structure_id in self.skopt_optimizers:
+                continue  # Avoid reinitializing existing structures
+            
+            dimensions = []
+            param_keys = []
+            
+            for step_idx, step in enumerate(candidate.pipeline.steps):
+                for key, config in sorted(step[1].configuration.items()):
+                    if key in self.ignored_configs:
+                        continue
+                    param_key = f"{step_idx}_{key}"
+                    
+                    value = config['value']
+                    if isinstance(value, (np.integer, np.floating, np.bool_)):
+                        value = value.item()
+                    
+                    if 'categorical' in config:
+                        dimensions.append(Categorical(config['categorical']))
+                    elif isinstance(value, bool):
+                        dimensions.append(Categorical([True, False]))
+                    elif isinstance(value, (int, float)):
+                        if 'range' in config:
+                            low, high = config['range']
+                            # Keep parameters with unbounded ranges fixed.
+                            if low is None or high is None:
+                                continue
+                            if low > high:
+                                low, high = high, low
+                            if isinstance(value, float):
+                                dimensions.append(Real(low, high))
+                            else:
+                                if low <= 0:
+                                    low = 1
+                                dimensions.append(Integer(low, high))
+                        else:
+                            if isinstance(value, float):
+                                dimensions.append(Real(-1e6, 1e6))
+                            else:
+                                dimensions.append(Integer(1, 1_000_000)) # TODO Pas de int négatif ? 
+                    else:
+                        # None and other values without a search domain stay unchanged.
+                        continue
+                    param_keys.append(param_key)
+            
+            if not dimensions:
+                continue
+            Logger().info(f"Initializing Bayesian Optimizer for structure {structure_id} with {len(dimensions)} dimensions")
+            self.skopt_optimizers[structure_id] = {'optimizer': Optimizer(dimensions), 'param_keys': param_keys, 'dimensions': dimensions}
+    
+    def _suggest_new_candidates(self, candidates):
+        """Suggest a new set of candidates using Bayesian Optimization."""
+        new_candidates = []
+        for candidate in candidates:
+            structure_id = self._generate_structure_id(candidate)
+            optimizer_data = self.skopt_optimizers.get(structure_id)
+            if not optimizer_data:
+                Logger().warning(f"Missing optimizer for structure {structure_id}")
+                continue
+            
+            try:
+                new_params = optimizer_data['optimizer'].ask(n_points=1)[0]
+            except:
+                new_params = None
+                
+            if new_params and len(new_params) != len(optimizer_data['param_keys']):
+                Logger().error(f"Parameter mismatch: expected {len(optimizer_data['param_keys'])}, got {len(new_params)}")
+                continue
+            
+            new_candidate = deepcopy(candidate)
+            idx = 0
+            if new_params:
+                for step_idx, step in enumerate(new_candidate.pipeline.steps):
+                    for key, config in sorted(step[1].configuration.items()):
+                        if key in self.ignored_configs:
+                            continue
+                        param_key = f"{step_idx}_{key}"
+                        if param_key in optimizer_data['param_keys']:
+                            if isinstance(new_params[idx], (np.integer, np.floating, np.bool_)):
+                                step[1].configure(key, new_params[idx].item())
+                            else:
+                                step[1].configure(key, new_params[idx])
+                            idx += 1
+                new_candidates.append(new_candidate)
+        
+        return new_candidates
+    
+    def _export_params(self, candidate, optimizer_data):
+        params = [None]*len(optimizer_data['param_keys'])
+        for step_idx, step in enumerate(candidate.pipeline.steps):
+            for key, config in sorted(step[1].configuration.items()):
+                if key in self.ignored_configs:
+                    continue
+                param_key = f"{step_idx}_{key}"
+                if param_key in optimizer_data['param_keys']:
+                    try:
+                        param_index = optimizer_data['param_keys'].index(param_key)
+                        value = config['value']
+                        if isinstance(value, (np.integer, np.floating, np.bool_)):
+                            value = value.item()
+                        
+                        dimension = optimizer_data['dimensions'][param_index]
+                        if isinstance(dimension, (Integer, Real)) and isinstance(value, (int, float)):
+                            bounds = dimension.bounds
+                            value = max(min(value, bounds[1]), bounds[0])
+                        params[param_index] = value
+                    except IndexError as e:
+                        Logger().error(f"IndexError: {str(e)} - param_key: {param_key}, param_keys: {optimizer_data['param_keys']}")
+                        continue
+        return params
+    
+    def run(self, candidates):
+        """
+        Perform Bayesian Optimization iteration.
+        :param candidates: List of Candidate objects to optimize.
+        :return: New list of candidates optimized using Bayesian Optimization.
+        """
+        if self.current_iteration == 0:
+            self._initialize_search_space(candidates)
+        
+        candidates.sort(reverse=True)
+        
+        for candidate in candidates:
+            structure_id = self._generate_structure_id(candidate)
+            optimizer_data = self.skopt_optimizers.get(structure_id)
+            if not optimizer_data:
+                Logger().warning(f"Skipping candidate {structure_id}, missing optimizer")
+                continue
+            
+            params = self._export_params(candidate, optimizer_data)
+            
+            main_metric = candidate.get_main_metric_score()
+            if isinstance(main_metric, (np.integer, np.floating)):
+                main_metric = main_metric.item()
+            if not isinstance(main_metric, (int, float)) or not np.isfinite(main_metric):
+                Logger().error(f"Invalid main_metric: expected finite scalar, got {type(main_metric)} - {main_metric}")
+                continue
+            
+            try:
+                # skopt minimizes its objective, while IAML maximizes candidate scores.
+                optimizer_data['optimizer'].tell([params], [-main_metric])
+            except ValueError as e:
+                Logger().error(f"Error in skopt.tell(): {str(e)}. Params: {params}, Bounds: {optimizer_data['optimizer'].space.bounds}")
+                continue
+            
+        keep_candidates = candidates[0:self.max_candidates//2]
+        new_candidates = self._suggest_new_candidates(keep_candidates)
+        self.current_iteration += 1
+        
+        # return self._suggest_new_candidates(candidates) # DEBUG
+        return keep_candidates + new_candidates
+    
+    @property
+    def finished(self) -> bool:
+        """
+        Check if optimization is finished.
+        :return: Boolean indicating if optimization is complete.
+        """
+        return self.current_iteration >= self.max_iterations

iaml/optimizers/genetic_optimizer.py

@@ -0,0 +1,284 @@
+"""Pipeline optimizer based on genetic concepts"""
+from copy import deepcopy
+import random
+import time
+from typing import Any
+from ..candidate import Candidate
+from .optimizer import Optimizer
+from ..step import Step
+from ..void_step import VoidStep
+
+
+class GeneticOptimizer(Optimizer): # pylint: disable=too-many-instance-attributes
+    """Pipeline optimizer based on genetic concepts
+    
+    :param int, optional nb_candidate: Number of candidates to optimize. Default to 35.
+    :param float, optional mutation_power: Chance of a mutation hapenning. Default to 0.1.
+    :param float, optional initial_modifier: Maximum modification value possible. Default to 5.
+    :param int, optional duration: Used to compute a mutation ratio. Default to None.
+    """
+
+    def __init__(
+        self,
+        nb_candidate: int = 35,
+        mutation_power: float = 0.1,
+        initial_modifier: float = 5,
+        duration: int = None) -> None:
+        super().__init__()
+        self.number_of_candidate: int = max(nb_candidate, 4)
+        """Maxmimum number of candicates"""
+
+        self.generation_count: int = 0
+        """Generation coutner"""
+
+        self.ignored_configs: set[str] = {'random_state'}
+        """Set of config keys to ignore"""
+
+        self.mutation_power: float = mutation_power
+        """Chance of a mutation hapenning"""
+
+        self.initial_modifier: float = initial_modifier
+        """Maximum modification value possible"""
+
+        self.max_generations: int = 200
+        """Maximum number of generations"""
+
+        self.first_candidate_pool: list[Candidate] = None
+        """List of candidates for the first generation"""
+
+        self.duration: int = duration
+        """Used to compute a mutation ratio"""
+
+        self.start_time: float = time.time()
+        """Starting time of the first generation"""
+
+    @property
+    def __mutate_ratio(self) -> float:
+        """Define a mutation ratio"""
+        if not self.duration:
+            return 0.5
+        return min(0.9, max(0.1, ((time.time() - self.start_time) / self.duration)))
+
+    @property
+    def finished(self) -> bool:
+        """Is optimization finished ?
+    
+        :return: finished ?
+        """
+        return self.generation_count >= self.max_generations
+
+    def run(self, candidates: list[Candidate]) -> list[Candidate]:
+        """Run one optimisation stage. Run of Optimzer have to be overwrite (do nothing).
+
+        :param list[Candidate] candidates: List of candidates to optimize
+        :return: Optimized candidates
+        """
+        candidates.sort(reverse=True)
+
+        # Will be used for random generation
+        if self.first_candidate_pool is None:
+            self.first_candidate_pool = candidates[0:6]
+
+        nb_to_keep: int = round(self.number_of_candidate / 4)
+        # nb_to_keep: int = max(min(4, round(self.number_of_candidate / 4)), 1)
+        mutate_ratio = self.__mutate_ratio
+        self.generation_count += 1
+
+        # Keep best pipelines
+        new_generation = [deepcopy(candidate) for candidate in candidates[0:nb_to_keep]]
+
+        for _ in range(int(self.number_of_candidate*mutate_ratio)):
+            new_generation.append(self.__mutate(random.choice(candidates[0:nb_to_keep])))
+
+        new_generation = [item for item in new_generation if item is not None] # remove None
+
+        while len(new_generation) < self.number_of_candidate:
+            new_generation.append(
+                self.__random_configuration(random.choice(candidates))
+            )
+
+        new_generation = [item for item in new_generation if item is not None] # remove None
+
+        return self.__unique(new_generation) # Remove duplicated
+
+    def __random_configuration(self, candidate: Candidate) -> Candidate:
+        """From a candidate generate a new one with a full random configuration
+
+        :param Candidate candidate: Candidate used to generate a new one
+        :return: Newly generated Candidate
+        """
+        # Deepcopy to avoid editing other Steps of the same generation
+        new_candidate: Candidate = deepcopy(candidate)
+
+        for current_step in new_candidate.pipeline.optimizable_step:
+
+            # If interchangeable -> 1/2 to change the step
+            if current_step.is_interchangeable and bool(random.getrandbits(1)):
+                new_step = self.__interchange(current_step)
+                new_candidate.pipeline.replace_step(current_step, new_step)
+                current_step = new_step
+            if not self.__config_keys(current_step):
+                continue # Nothing to optimize
+
+            # For each configuration key, we'll choose a random value
+            for key in self.__config_keys(current_step):
+
+                # 1/2 chance to let the default value unchanged
+                if bool(random.getrandbits(1)):
+                    continue
+
+                config = current_step.configuration[key]
+
+                if type(config['value']) in [int, float]: # Numeric value ? Let's apply multiplier
+                    is_int = isinstance(config['value'], int)
+
+                    new_value = None
+                    if 'range' in config: # Random in range
+                        new_value = random.uniform(*config['range'])
+                    else: # Kind of strong mutate
+                        # Randomly choose a positive or negative editing
+                        if bool(random.getrandbits(1)):
+                            # Negative -> Multiply value by something between 0.01 and 1
+                            change_rate = random.uniform(0.01, 1)
+                            new_value = config['value']*change_rate
+                        else:
+                            # Positive -> Multiply value by something between 1
+                            # and the max modificator in configuration
+                            change_rate = random.uniform(1, self.initial_modifier)
+                            new_value = config['value']*change_rate
+
+                    # Value was a int ? Round it to keep it int
+                    if is_int:
+                        new_value = round(new_value)
+
+                    if not self.__valide_config(config, new_value):
+                        # Cancel is the new value is not correct.
+                        new_value = config['value']
+
+                # Categorical value, choose randomly one of them
+                elif 'categorical' in config.keys():
+                    new_value = random.choice(config['categorical'])
+                elif isinstance(config['value'], bool):
+                    # Bool value, choose randomly beetwen True and False
+                    new_value = random.choice([True, False])
+                else: # Other value ? Just keep it
+                    new_value = config['value']
+
+                current_step.configure(key, new_value) # Set new configuration in the step
+
+        return new_candidate
+
+    def __mutate(self, candidate: Candidate) -> Candidate:
+        """Mutate a candidate into a new one
+        
+        :param Candidate candidate: Candidate used for the mutation.
+        :return: Newly created Candidate.
+        """
+        new_candidate: Candidate = deepcopy(candidate)
+        steps = new_candidate.pipeline.optimizable_step
+        if not steps:
+            return None
+        step_to_mutate: Step = random.choice(steps)
+
+        mutable_keys = self.__config_keys(step_to_mutate)
+        if step_to_mutate.is_interchangeable:
+            mutable_keys.append("interchange")
+
+        if not mutable_keys:
+            return None # Nothing to optimize
+
+        # Choose a random key to mutate
+        random_key: str = random.choice(mutable_keys)
+
+        if random_key == "interchange": # Mutate by interchanging the step with sibling
+            new_step = self.__interchange(step_to_mutate)
+            new_candidate.pipeline.replace_step(step_to_mutate, new_step)
+            return new_candidate
+
+
+        random_item: dict = step_to_mutate.configuration[random_key] # Get value of the random key
+        new_value = None
+
+        if type(random_item['value']) in [int, float]: # Numeric value ? Apply multiplier
+            is_int = isinstance(random_item['value'], int)
+
+            # Find a multiplier between - mutation_power & + mutation_power
+            change_rate = random.uniform(-self.mutation_power, self.mutation_power)
+            new_value = random_item['value']*(1+change_rate) # Apply random multiplier
+
+            # Value was a int ? Round it to keep it int
+            if is_int:
+                new_value = round(new_value)
+
+            if new_value == random_item['value']: # To be sure there is a mutation
+                new_value += random.choice([-1, 1])
+
+            if not self.__valide_config(random_item, new_value):
+                # Cancel if the new value is not correct.
+                new_value = random_item['value']
+
+        elif 'categorical' in random_item.keys(): # Categorial -> Choose one
+            new_value = random.choice(random_item['categorical'])
+        elif isinstance(random_item['value'], bool): # Bool -> Choose between True and False
+            new_value = random.choice([True, False])
+        else: # Other -> Keep it
+            new_value = random_item['value']
+
+        step_to_mutate.configure(random_key, new_value) # Apply configuration
+
+        return new_candidate
+
+    @staticmethod
+    def __interchange(step: Step) -> Step:
+        """Choose another implementation, allowing optional preprocessing to be removed."""
+        choices = [sibling for sibling in step.step_with_same_tags()
+                   if sibling is not type(step)]
+        if (not isinstance(step, VoidStep) and step.can_be_disabled
+                and not hasattr(step, 'predict')
+                and (hasattr(step, 'transform') or hasattr(step, 'resample'))):
+            choices.append(VoidStep)
+        if not choices:
+            return step
+        step_class = random.choice(choices)
+        if step_class is VoidStep:
+            replacement = VoidStep(step_to_mimic=type(step)())
+        else:
+            replacement = step_class()
+        replacement.is_interchangeable = True
+        return replacement
+
+    def __config_keys(self, step: Step) -> list[str]:
+        """Get a list of config keys used for a Step
+        
+        :param Step step: The step we want the config
+        :return: List of config keys for this step
+        """
+        if not step.optimizable:
+            return []
+        return list(set(step.configuration.keys()) - self.ignored_configs)
+
+    def __valide_config(self, config: dict, value: Any) -> bool:
+        """Is the configuration range valid ?
+        
+        :param dict config: The config to validate.
+        :return: Valid ?
+        """
+        if 'range' not in config.keys():
+            return True
+        return config['range'][0] <= value <= config['range'][1]
+
+    def __unique(self, candidates: list[Candidate]) -> list[Candidate]:
+        """Get a list of unique Candidates
+
+        :param list[Candidate] candidates: List of Candidate.
+        :return: List of unique Candidate
+        """
+        unique_candidates: list[Candidate] = []
+        unique_fingerprint: list[str] = []
+        for candidate in candidates:
+            fingerprint: str = candidate.pipeline.fingerprint()
+            if fingerprint not in unique_fingerprint:
+                unique_candidates.append(candidate)
+                unique_fingerprint.append(fingerprint)
+
+        return unique_candidates

iaml/optimizers/optimizer.py

@@ -0,0 +1,31 @@
+
+"""Base class of IAML Optimizer. Optimizer receive a pool of Candidates, 
+optimize parameters and return a new pool of candidate
+"""
+from ..candidate import Candidate
+
+
+class Optimizer:
+    """Base class of IAML Optimizer. Optimizer receive a pool of Candidates, 
+    optimize parameters and return a new pool of candidate
+    """
+    def __init__(self):
+        self.__finished: bool = False
+        """Is the optimization done ?"""
+
+    @property
+    def finished(self) -> bool:
+        """Is the optimization finished ?
+
+        :return: Finished ?
+        """
+        return self.__finished
+
+    def run(self, candidates: list[Candidate]) -> list[Candidate]:
+        """Run one optimisation stage. Run of Optimzer have to be overwrite (do nothing).
+
+        :param list[Candidate] candidates: List of candidates to optimize
+        :return: Optimized candidates
+        """
+        self.__finished = True
+        return candidates