PyIAML 1.0.0__py3-none-any.whl

iaml/type_of_target.py

@@ -0,0 +1,68 @@
+"""Try to figure out the type of target"""
+from typing import Any
+import numpy as np
+from sklearn.utils.multiclass import type_of_target as sk_type_of_target
+
+
+def type_of_target(y: list) -> str:
+    """Try to figure out the type of target
+
+    :param List y: Dataset's target
+    :return: type of target (binary, continuous, multi-label, etc.)
+    """
+    y = np.array(y)
+
+    # Survival target -> list[tuple[bool, int]]
+    if is_survival(y):
+        return 'survival'
+
+    if np.issubdtype(y.dtype, np.number):
+        unique_count = len(np.unique(y))
+        if unique_count > len(y) * 0.2 or unique_count > 10:
+            return 'continuous'
+
+    return sk_type_of_target(y)
+
+def is_survival(y: list[tuple[Any, Any]]) -> bool:
+    """Checks if the input data represents survival data.
+    
+    Survival data is expected to be a list of tuples where:
+    - The first element of each tuple is binary-like
+    - The second element of each tuple is numeric (int or float).
+    
+    :param list[tuple[Any, Any]] y: each tuple contains two elements (binary-like, numeric).
+    :return: True if the data meets the survival data requirements, False otherwise.
+    """
+    
+    # Ensure all elements are tuples of length 2
+    if not all(isinstance(row, (tuple, np.ndarray)) and len(row) == 2 for row in y):
+        return False
+
+    # Check if the first element of all tuples is binary-like
+    first_elements = [row[0] for row in y]
+    if not is_bool_convertible(first_elements):
+        return False
+    
+    # Check if the second element of all tuples is numeric (int or float)
+    if not all(isinstance(row[1], (int, float, np.integer, np.floating)) for row in y):
+        return False
+
+    return True
+
+def is_bool_convertible(seq):
+    for element in seq:
+        if isinstance(element, (bool, np.bool_)):
+            continue
+        elif isinstance(element, (int, np.integer)):
+            if element in (0, 1):
+                continue
+            else:
+                return False
+        elif isinstance(element, (float, np.floating)):
+            if abs(element - 0.0) < 1e-9 or abs(element - 1.0) < 1e-9:
+                continue
+            else:
+                return False
+        else:
+            return False
+    return True

iaml/void_step.py

@@ -0,0 +1,101 @@
+"""[STEP] Void step -> Just a step that do nothing and can be mutated to siblings"""
+from hashlib import md5
+import json
+
+import pandas as pd
+from .step import Step
+from .decorators.all import is_step
+from .dataset import Dataset
+
+
+def predict(X: pd.DataFrame) -> pd.DataFrame:
+    """VoidStep : Do nothing
+    
+    :param pd.DataFrame X: The dataframe we predict on
+    :return: The dataframe returned
+    """
+    return X
+
+
+def transform(dataset: Dataset) -> Dataset:
+    """VoidStep : Do nothing
+    
+    :param Dataset dataset: The Dataset object we transform
+    :return: The transformed Dataset
+    """
+    return dataset
+
+
+def resample(X: pd.DataFrame, y: list) -> tuple[pd.DataFrame, list]:
+    """VoidStep : Do nothing
+    
+    :param pd.DataFrame X: The dataframe to resample
+    :param List y: The dataframe target to resample
+    :return: The resampled X and y
+    """
+    return X, y
+
+
+@is_step()
+class VoidStep(Step):
+    """[STEP] Void step -> Just a step that do nothing and can be mutated to siblings
+    
+    :param Tuple, optional args: Additional parameters
+    :param Step, optional step_to_mimic: The step to mimic, if provided
+    :param Dict, optional kwargs: Additional parameters
+    """
+    _usage: str = "Use when you need a no-op placeholder that mimics another step during search, unlike Actionable. Applicable to any dataset when inputs must pass through unchanged. Avoid when you need a real operation or orchestration; consider MetaStep or MetaOrderedStep."
+    name: str = "VoidStep"
+    def __init__(self, *args, step_to_mimic: Step = None, **kwargs) -> None:  # pylint: disable=unused-argument
+        """VoidStep : Do nothing"""
+        if step_to_mimic:
+            self.tags = step_to_mimic.tags
+            self.step_to_mimic = step_to_mimic
+            self.is_interchangeable = True
+            self.optimizable = True
+
+            if hasattr(step_to_mimic, 'predict') and callable(step_to_mimic.predict):
+                self.predict = predict
+            elif hasattr(step_to_mimic, 'transform') and callable(step_to_mimic.transform):
+                self.transform = transform
+            elif hasattr(step_to_mimic, 'resample') and callable(step_to_mimic.resample):
+                self.resample = resample
+
+    def fingerprint(self) -> str:
+        """Keep cached placeholders in their own operation and mutation family."""
+        mimic = getattr(self, 'step_to_mimic', None)
+        signature = (
+            super().fingerprint(),
+            sorted(self.tags or []),
+            mimic.fingerprint() if mimic is not None else None,
+        )
+        return md5(json.dumps(signature).encode()).hexdigest()
+
+    @classmethod
+    def from_pipeline(cls, pipeline: dict, *args, **kwargs) -> Step:
+        """Load any VoidStep from json pipeline
+
+        :param dict pipeline: Pipeline in a JSON format.
+        :param tuple, optional \\*args: Additional parameters.
+        :param dict, optional \\**kwargs: Additional parameters.
+        :raise TypeError: Invalid pipeline: VoidStep must have a Step to mimic
+        :return: Step created from Json pipeline
+        """
+        if not 'step_to_mimic' in pipeline:
+            raise TypeError('invalid pipeline: VoidStep must have a Step to mimic')
+
+        to_mimic = Step.from_pipeline(pipeline['step_to_mimic'])
+
+        step = super().from_pipeline(pipeline, step_to_mimic=to_mimic)
+
+        return step
+
+    def json_pipeline(self) -> dict:
+        """Create JSON pipeline
+
+        :return: Pipeline in JSON format
+        """
+        return {
+            **Step.json_pipeline(self),
+            'step_to_mimic': self.step_to_mimic.json_pipeline()
+        }

iaml/worker_manager.py

@@ -0,0 +1,169 @@
+"""This implementation adds a level of abstraction to futures, allowing us to
+manage the worker queue with more control, and keep multithreading code
+within the steps as simple as possible.
+"""
+import math
+import os
+import traceback
+
+from concurrent.futures import ThreadPoolExecutor, Future
+from typing import Any
+from .logger import Logger
+from .meta_singleton import MetaSingleton
+from .step import Step
+
+
+class WorkerFuture(Future):
+    """Thread Step
+
+    :param Step step: The step that will be performed by the Thread
+    :param callable task: The function to run on the thread
+    :param tuple, optional args: callable parameters
+    :param dict, optional kwargs: callable parameters
+    """
+    def __init__(self, step: Step, task: callable, *args, **kwargs) -> None:
+        super().__init__()
+
+        self.step: Step = step
+        """The step that will be performed by the Thread"""
+
+        self.task: callable = task
+        """The function to run on the thread"""
+
+        self.args: tuple = args
+        """Optional parameters to be passed to the callable"""
+
+        self.kwargs: dict = kwargs
+        """Optional parameters to be passed to the callable"""
+
+    def run(self) -> Any:
+        """Run the thread and execute the affected task
+        In case of error, log them and return an empty list
+        
+        :return: The task result or an empty list in case of errors.
+        """
+        try:
+            return self.task(*self.args, **self.kwargs)
+        except:  # pylint: disable=bare-except
+            Logger().error(f'[red]A worker for [b]{self.step.__class__.__name__}[/b] \
+                has crashed.[/red]')
+            Logger().error(traceback.format_exc())
+
+            return []
+
+
+class WorkerManager(metaclass=MetaSingleton):
+    """This implementation adds a level of abstraction to futures, allowing us to
+    manage the worker queue with more control, and keep multithreading code
+    within the steps as simple as possible.
+
+    This worker manager acts as a smarter thread pool executor, which is able
+    to enqueue resource-intensive tasks in order to limit the amount of active
+    threads while still allowing jobs to complete when they depend on "child"
+    jobs, preventing deadlocks.
+
+    Reference: https://docs.python.org/3/library/concurrent.futures.html#threadpoolexecutor.
+    
+    :param int, optional max_workers: Maximum number of parallel workers
+    """
+    def __init__(self, max_workers: int = None) -> None:
+        self.active_workers_count: int = 0
+        """Hold the current number of active workers"""
+
+        self.executor: ThreadPoolExecutor = ThreadPoolExecutor(
+            max_workers=math.inf,
+            thread_name_prefix='WorkerManager')
+        """ThreadPoolExecutor object, handling workers"""
+
+        self.max_workers: int = max_workers or os.cpu_count()
+        """The maximum number of paralllel workers"""
+
+        self.running_futures: list[WorkerFuture] = []
+        """List of running workers"""
+
+        self.running_parents: list[list[int]] = []
+        """List of Lists for parents ids"""
+
+        self.queue: list[WorkerFuture] = []
+        """List of worker pending"""
+
+    def __done_callback(self, base_future: Future, worker_future: WorkerFuture) -> None:
+        """Function called when a thread is done working
+        
+        :param Future base_future: basic asynchronous task
+        :param WorkerFuture worker_future: Our asynchronous thread task
+        """
+        worker_future.set_result(base_future.result())
+
+        self.active_workers_count -= 1
+        self.running_futures.remove(worker_future)
+
+        self.run_next(worker_future.step)
+
+    def is_sibling_running(self, step: Step) -> bool:
+        """Checks whether a sibling of `step` is currently running.
+        
+        :param Step step: The step we are working on
+        :return: Either the parent steps of our steps is running in an asynchronous thread
+        """
+        return step.parents_steps in [ f.step.parents_steps for f in self.running_futures ]
+
+    def run(self, future: WorkerFuture) -> None:
+        """Immediately starts `future`.
+        
+        :param WorkerFuture future: The asynchronous task to run
+        """
+        # parents are supposed to wait for their children to complete before
+        # doing anything else, so they are not an "active" worker as long as
+        # they have children: "release" a worker
+        if future.step.parents_steps not in self.running_parents:
+            self.running_parents.append(future.step.parents_steps)
+
+        self.active_workers_count += 1
+        self.running_futures.append(future)
+
+        f = self.executor.submit(future.run)
+        f.add_done_callback(lambda _f: self.__done_callback(_f, future))
+
+    def run_next(self, current_step: Step) -> None:
+        """Finds a sibling of `current_step`, and starts it. This should be used
+        when a future is done running. If there is no sibling, start whatever
+        is next in the queue.
+        
+        :param Step current_step: The current step we need to find the siblings
+        """
+        next_sibling_in_queue = next(( f for f in self.queue \
+            if current_step.parents_steps == f.step.parents_steps ), None)
+
+        if next_sibling_in_queue is not None:
+            self.queue.remove(next_sibling_in_queue)
+            self.run(next_sibling_in_queue)
+        else:
+            if current_step.parents_steps in self.running_parents:
+                # all the children have completed: "unrelease" a worker
+                self.running_parents.remove(current_step.parents_steps)
+
+            if (self.active_workers_count - len(self.running_parents) + 1) < self.max_workers \
+                and len(self.queue) > 0:
+                self.run(self.queue.pop())
+
+    def submit(self, step: Step, task: callable, *args, **kwargs) -> WorkerFuture:
+        """Submits a job to the worker manager, and returns a wrapped future which
+        can be used to wait for the job to end, even if it's not started yet
+        (as opposed to jobs submitted to a `ThreadPoolExecutor`).
+        
+        :param Step step: The step we submit to the asynchronous task
+        :param callable task: The function to run on our asynchronous task
+        :param Tuple, optional args: callable parameters
+        :param Dict, optional kwargs: callable parameters
+        :return: The future we just created
+        """
+        future = WorkerFuture(step, task, *args, **kwargs)
+
+        if (self.active_workers_count - len(self.running_parents) + 1) < self.max_workers \
+            or not self.is_sibling_running(step):
+            self.run(future)
+        else:
+            self.queue.append(future)
+
+        return future

iaml/wrapper/__init__.py

@@ -0,0 +1,4 @@
+"""All Wrapper Steps"""
+from .wrap_basic_gridsearch import WrapBasicGridSearch
+from .wrap_iterative_gridsearch import GridIteration, WrapIterativeGridSearch
+from .wrap_genetic_gridsearch import WrapGeneticGridSearch

iaml/wrapper/wrap_basic_gridsearch.py

@@ -0,0 +1,68 @@
+"""[WRAPPER] Wrap a step to apply Grid Search configuration parameters"""
+from copy import deepcopy
+from itertools import product
+
+from ..step_wrapper import StepWrapper
+from ..candidate import Candidate
+from ..decorators.all import is_step, runner
+
+
+@is_step('wrapper')
+class WrapBasicGridSearch(StepWrapper):
+    """[WRAPPER] Wrap a step to apply Grid Search configuration parameters"""
+
+    _usage: str = "Use when you want a quick, simple grid around current values and prefer it over WrapGeneticGridSearch or WrapIterativeGridSearch. Applicable to numeric, categorical, and boolean hyperparameters. Avoid when search space is large or needs adaptive or iterative exploration."
+    to_avoid: list[str] = ['random_state'] # List of ignored key
+
+    @runner
+    def run(self, candidate: Candidate) -> list[Candidate]:
+        """Super basic GridSearch.
+        
+        - Numeric values -> 11 runs with 10% (50% to 150%)
+        - Categorial values -> 1 run each
+        - Boolean values -> Run with True and False
+        - Other -> keep current value
+
+        :param Candidate candidate: Candidate data
+        :return: All transformed candidates
+        """
+
+        to_explore = {}
+
+        for key, item in self.step.configuration.items():
+            if key in self.to_avoid or item.get('no_gridsearch'):
+                continue
+
+            if 'categorical' in item.keys(): # Categorical
+                to_explore[key] = item['categorical']
+            elif type(item['value']) in [int, float]: # Numeric
+                current_value = item['value']
+
+                tmp = [factor * current_value for factor in
+                       [.5, .6, .7, .8, .9, 1, 1.1, 1.2, 1.3, 1.4, 1.5]]
+
+                # Keep int
+                if isinstance(item['value'], int):
+                    tmp = [round(x) for x in tmp]
+
+                # Check range
+                if 'range' in item.keys():
+                    lower, upper = item['range']
+                    tmp = [value for value in tmp
+                           if (lower is None or lower <= value)
+                           and (upper is None or value <= upper)]
+
+                to_explore[key] = list(dict.fromkeys(tmp))
+
+            elif isinstance(item['value'], bool): # Bool
+                to_explore[key] = [True, False]
+            else: # Other
+                to_explore[key] = [item['value']]
+
+        candidates = []
+        for values in product(*to_explore.values()):
+            step = deepcopy(self.step)
+            step.configure(dict(zip(to_explore, values)))
+            results = step.run(candidate.to_output())
+            candidates.extend([results] if isinstance(results, Candidate) else results)
+        return candidates