pico-ml 2.0.0__py3-none-any.whl

pico/__init__.py

@@ -0,0 +1,3 @@
+from .ui import app
+
+__version__ = "2.0.0"

pico/__main__.py

@@ -0,0 +1,3 @@
+from .cli.main import app
+
+app()

pico/cli/__init__.py

@@ -0,0 +1,2 @@
+from rich.console import Console
+console = Console()

pico/cli/main.py

@@ -0,0 +1,117 @@
+import subprocess
+import sys
+import time
+import webbrowser
+import threading
+
+from typing import Annotated, Optional
+
+import typer
+
+from . import console
+from .. import __version__
+from .. import app as pico_app
+
+# Use print from `rich` library
+print = console.print
+
+app = typer.Typer()
+
+PYPI_PROJECT_NAME = "pico-ml"
+
+@app.callback(invoke_without_command=True, no_args_is_help=True)
+def main(
+    version: bool = typer.Option(False, "--version", "-v", help="PICO CLI version")
+):
+    """
+    PICO CLI!
+    """
+    if version:
+        typer.echo(__version__)
+        typer.Exit()
+
+
+@app.command(name="ui")
+def ui(
+    port: Annotated[Optional[int], typer.Option("--port", "-p", help="Specify the port of the app")] = 5000,
+    verbose: Annotated[Optional[str], typer.Option("--verbose", "-v", help="Specifiy verbosity")] = "debug"
+):
+    """Launch the web application"""
+    print("verbose", verbose)
+    page_url = f"http://127.0.0.1:{port}"
+
+    def startWebPage(url, wait_time: int = 0):
+        """Open a browser on localhost at a url after a given wait_time"""
+        time.sleep(wait_time)
+        webbrowser.open(url)
+    
+    start_web_page_thread = threading.Thread(
+        target=startWebPage,
+        args=(page_url, 5)
+    )
+    start_web_page_thread.start()
+    pico_app.run(debug=False, host='0.0.0.0', port=port)
+
+
+@app.command()
+def update():
+    """Update the pico project to the latest version"""
+
+    # See https://stackoverflow.com/a/50255019 for installation of a python package
+    pip_infos = (
+        subprocess.run(
+            [sys.executable, "-m", "pip", "show", PYPI_PROJECT_NAME],
+            check=True,
+            capture_output=True,
+        )
+        .stdout.decode('latin-1')
+        .split("\n")
+    )
+
+    editable_identifier_str = "Editable project location: "
+    editable_project_location = [l for l in pip_infos if editable_identifier_str in l]
+    if editable_project_location:
+        print(
+            "[cyan]pico[/cyan] is installed in editable mode, it should already be up to date."
+        )
+        print(f"Current version: {__version__}")
+        return
+
+    # pico was installed with pipx
+    if "pipx" in sys.executable:
+        print("[cyan]pico[/cyan] is managed by [cyan]pipx[/cyan]")
+        update_function = [
+            "pipx",
+            "upgrade",
+            PYPI_PROJECT_NAME
+        ]
+        print("The following command will update [cyan]pico[/cyan]:")
+        print(" ".join(update_function), end="\n\n")
+        typer.confirm("Do you want to proceed?", abort=True)
+
+        # pipx is verbose enough
+        subprocess.run(update_function, check=True)
+        return
+
+    # Update pico with the current Python interpreter
+    update_function = [
+        sys.executable,
+        "-m",
+        "pip",
+        "install",
+        "-U",
+        PYPI_PROJECT_NAME
+    ]
+    print("The following command will update [cyan]pico[/cyan]:")
+    print(" ".join(update_function), end="\n\n")
+    typer.confirm("Do you want to proceed?", abort=True)
+
+    subprocess.run(update_function, check=True, capture_output=True)
+    new_version = subprocess.run(
+        [sys.executable, "-m", "pico", "--version"], capture_output=True
+    ).stdout.decode().strip()
+    print(f"[cyan]pico[/cyan] updated to {new_version}")
+
+
+# This is expose for documentation purposes
+typer_click_object = typer.main.get_command(app)

pico/conf/SupportedCV.py

@@ -0,0 +1,17 @@
+from sklearn.model_selection import GridSearchCV, RandomizedSearchCV
+
+CV_ALGORITHMS = {
+    "GridSearchCV": {
+        "constructor": GridSearchCV,
+        "params": []
+    }, 
+    "RandomizedSearchCV": {
+        "constructor": RandomizedSearchCV,
+        "params": [{
+            "name": "n_iter", 
+            "value": 10, 
+            "type": "int", 
+            "constant": False
+        }]
+    }
+}

pico/conf/SupportedModels.py

@@ -0,0 +1,73 @@
+import numpy as np
+from pyscm.scm import SetCoveringMachineClassifier
+from randomscm.randomscm import RandomScmClassifier
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.tree import DecisionTreeClassifier
+
+LEARN_CONFIG = {
+    "DecisionTree": {
+        "function": DecisionTreeClassifier,
+        "ParamGrid": {
+            "RandomSearch": {
+                "max_depth": np.arange(2, 9, step=1, dtype=int),
+                "min_samples_split": np.arange(2, 20, step=2, dtype=int),
+                "max_features": ["sqrt", "log2"],
+            },
+            "GridSearch": {
+                "max_depth": [2, 3, 4, 5, 6, 7],
+                "min_samples_split": [2, 4, 6, 8, 10],
+                "max_features": ["sqrt", "log2"],
+                "class_weight": ["balanced"]
+            }
+        },
+        "importance_attribute": "feature_importances_",
+    },
+    "RandomForest": {
+        "function": RandomForestClassifier,
+        "ParamGrid": {
+            "RandomSearch" : {
+                "n_estimators": np.arange(5, 300, step=10, dtype=int),
+                "max_depth": np.arange(2, 6, step=1, dtype=int), #[1, 2, 3, 4, 5],
+                "min_samples_split": np.arange(2, 20, step=2, dtype=int),
+            },
+            "GridSearch" : {
+                "n_estimators": [10, 30, 50, 70, 100, 200],  # removed 5,
+                "max_depth": [2, 3, 4, 5],
+                "min_samples_split": [2, 4, 6, 8, 10]
+            }
+        },
+        "importance_attribute": "feature_importances_",
+    },
+    "SCM": {
+        "function": SetCoveringMachineClassifier,
+        "ParamGrid": {
+            "RandomSearch" : {
+                "p": np.logspace(-2, 2, base=10, num=30),
+                "max_rules": np.arange(1, 6, 1, dtype=int),
+                "model_type": ["conjunction", "disjunction"],
+            },
+            "GridSearch" : {
+                "p": np.logspace(-2, 2, base=10, num=7), #[0.01, 0.1, 1, 10],
+                "max_rules": [1, 2, 3, 4, 5],
+                "model_type": ["conjunction", "disjunction"],
+            }
+        },
+        "importance_attribute": "feature_importances_",
+    },
+    "RandomSCM": {
+        "function": RandomScmClassifier,
+        "ParamGrid": {
+            "RandomSearch" : {
+                "p": np.logspace(-2, 2, base=10, num=30),
+                "n_estimators": np.arange(5, 200, step=10, dtype=int),
+                "model_type": ["conjunction", "disjunction"],
+            },
+            "GridSearch" : {
+                "p": np.logspace(-2, 2, base=10, num=5),
+                "n_estimators": [5, 10, 30, 50, 70, 100, 200],
+                "model_type": ["conjunction", "disjunction"],
+            },
+        },
+        "importance_attribute": "feature_importances_",
+    },
+}

pico/conf/algo_sklearn.json

@@ -0,0 +1,51 @@
+{
+  "DecisionTree": {
+    "function": "DecisionTreeClassifier",
+    "ParamGrid": {
+      "max_depth": [
+        1,
+        2,
+        3,
+        4,
+        5,
+        10
+      ],
+      "min_samples_split": [
+        2,
+        4,
+        6,
+        8,
+        10
+      ]
+    }
+  },
+  "RandomForest": {
+    "function": "RandomForestClassifier",
+    "ParamGrid": {
+      "n_estimators": [
+        1,
+        2,
+        4,
+        10,
+        30,
+        70,
+        100,
+        500,
+        1000
+      ]
+    }
+  },
+  "SVM_L1": {
+    "function": "LinearSVC",
+    "ParamGrid": {
+      "C": "np.logspace(-5, 5, 20)"
+    }
+  },
+  "SCM": {
+
+
+  },
+  "RandomSCM": {
+
+  }
+}

pico/conf/parameters.py

@@ -0,0 +1,14 @@
+# Number of features to compute PCA, UMAP and Strip charts
+features = [5, 10, 40, 100]
+
+# Default marks for sliders
+default_marks = {str(k): str(v) for k, v in enumerate(features)}
+
+# Mark for the all value
+all_mark = {str(len(features)): "All"}
+
+# Offset when showing the used value
+custom_mark_offset = 0.3
+
+# Limit of used features to plot (used for strip charts)
+max_used_features_to_show = 200

pico/domain/ClassificationDesign.py

@@ -0,0 +1,107 @@
+from typing import Generator, Tuple, Dict, Union
+
+from . import SplitGroup, MetaData
+from .Results import *
+
+
+class ClassificationDesign:
+    def __init__(self, classes_design: dict):
+        self._classes_design: dict = classes_design  # dict with labels as keys and classes as values
+        self._name: str = ""
+        self._compute_name()
+        self._split_group: Union[SplitGroup, None] = None
+        self._selected_models_name: Union[list, None] = None
+        self.design_Results: dict = {}
+        self._is_done: bool = False
+        self._balance_correction: int = 0
+
+    def get_is_done(self) -> bool:
+        """
+        Return the attribute is_done which is trigered when the learning is done
+        """
+        return self._is_done
+
+    def set_is_done(self, is_done: bool) -> None:
+        self._is_done = is_done
+
+    def get_balance_correction(self) -> int:
+        return self._balance_correction
+
+    def set_balance_correction(self, balance_correction: int) -> None:
+        if balance_correction < 0:
+            raise ValueError("Balance correction cannot be negative")
+        self._balance_correction = balance_correction
+
+    def set_split_parameter_and_compute_splits(self, train_test_proportion: float, number_of_splits: int,
+                                               metadata: MetaData, pairing_column: str, uniq_sample_id: List[str],
+                                               test_split_seed: int|None=None) -> None:
+        """
+        Retrieve the classes repartition which is needed to create an instance of SplitGroup
+        Create an instance of SplitGroup in the attribute _split_group
+        (The init of SplitGroup triggers the _compute_splits function).
+        If test_split_seed is provided, then only this test split seed is computed.
+        """
+        classes_repartition = metadata.get_classes_repartition_based_on_design(self._classes_design)
+        self._split_group = SplitGroup(metadata, self.get_selected_targets_name(), train_test_proportion,
+                                       number_of_splits, self._classes_design, pairing_column, uniq_sample_id, 
+                                       self._balance_correction, classes_repartition, test_split_seed)
+
+    def get_name(self) -> str:
+        return self._name
+
+    def get_full_name(self) -> str:
+        name = []
+        for key, item_list in self._classes_design.items():
+            name.append(f"{key} ({', '.join(item_list)})")
+        return " versus ".join(name)
+
+    def get_classes_design(self) -> dict:
+        return self._classes_design
+
+    def set_selected_models_name(self, selected_models_name: list) -> None:
+        """
+        Set the attribute self._selected_models_name
+        and create the attribute self.design_Results with initialized instances of the class Results for each algorithm
+        selected_models_name: list of names of models to run on data
+        """
+        if self._split_group is None:
+            raise ValueError("Trying to set models before setting splits parameters")
+        self._selected_models_name = selected_models_name
+        for n in self._selected_models_name:
+            self.design_Results[n] = Results(self._split_group.get_number_of_splits())
+
+    def get_results(self) -> Dict[str, Results]:
+        """
+        Return the results dict (attribute) corresponding to this instance of Classification Design
+        """
+        if self.design_Results == {}:
+            raise RuntimeError("The name of the selected models has to be set before accessing results.")
+        return self.design_Results
+
+    def _compute_name(self) -> None:
+        """
+        The name is made up of label1_vs_label2
+        Each label refering to a group of one or more classes from the data
+        """
+        self._name = "_vs_".join(self._classes_design)
+
+    def get_number_of_splits(self) -> int:
+        """
+        Retrieve the number of splits from SplitGroup instance
+        """
+        return self._split_group.get_number_of_splits()
+
+    def all_splits(self) -> Generator[Tuple[int, list], None, None]:
+        if self._split_group is None:
+            raise RuntimeError(
+                "Trying to access Splits before setting splits parameters"
+            )
+        for split_index in range(self._split_group.get_number_of_splits()):
+            yield split_index, self._split_group.load_split_with_index(split_index)
+
+    def get_selected_targets_name(self) -> list:
+        """
+        get the _classes_design dict in input and reverse it to have the classes as key and their corresponding labels
+        as value. It is then easier to retrieve a label for a specific class
+        """
+        return list(Utils.reverse_dict(self._classes_design).keys())