chaine 3.13.1__cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

chaine/logging.py

@@ -0,0 +1,214 @@
+"""
+chaine.logging
+~~~~~~~~~~~~~~
+
+This module implements a basic logger.
+"""
+
+import logging
+import sys
+from logging import Formatter, StreamHandler
+
+DEBUG = 10
+INFO = 20
+WARNING = 30
+ERROR = 40
+LEVELS = {"DEBUG": DEBUG, "INFO": INFO, "WARNING": WARNING, "ERROR": ERROR}
+
+DEFAULT_FORMAT = Formatter("[%(asctime)s] [%(levelname)s] %(message)s")
+DEBUG_FORMAT = Formatter("[%(asctime)s] %(name)s:%(lineno)d [%(levelname)s] %(message)s")
+
+
+class Logger:
+    def __init__(self, name: str):
+        """Basic logger
+
+        Parameters
+        ----------
+        name : str
+            Name of the logger
+        """
+        self.name = name
+
+        # return a logger with the specified name, creating it if necessary
+        self._logger = logging.getLogger(name)
+
+        # stream handler to stdout
+        self._stream_handler = StreamHandler(sys.stdout)
+        self._logger.addHandler(self._stream_handler)
+
+        # set level of both the logger and the handler to INFO by default
+        self.set_level("INFO")
+
+    def set_level(self, level: str | int):
+        # translate string to integer
+        if isinstance(level, str):
+            level = LEVELS[level.upper()]
+
+        # set the logger's level
+        self._logger.setLevel(level)
+
+        # and all handlers
+        for handler in self._logger.handlers:
+            handler.setLevel(level)
+
+            # optionally change the formatter (log more when in debug mode)
+            if level < INFO:
+                handler.setFormatter(DEBUG_FORMAT)
+            else:
+                handler.setFormatter(DEFAULT_FORMAT)
+
+    def debug(self, message: str):
+        """Debug log message
+
+        Parameters
+        ----------
+        message : str
+            Message to log
+        """
+        if self._logger.isEnabledFor(DEBUG):
+            self._logger._log(DEBUG, message, ())
+
+    def info(self, message: str):
+        """Info log message
+
+        Parameters
+        ----------
+        message : str
+            Message to log
+        """
+        if self._logger.isEnabledFor(INFO):
+            self._logger._log(INFO, message, ())
+
+    def warning(self, message: str):
+        """Warning log message
+
+        Parameters
+        ----------
+        message : str
+            Message to log
+        """
+        if self._logger.isEnabledFor(WARNING):
+            self._logger._log(WARNING, message, ())
+
+    def error(self, message: str | Exception):
+        """Error log message
+
+        Parameters
+        ----------
+        message : str
+            Message to log
+        """
+        if self._logger.isEnabledFor(ERROR):
+            if isinstance(message, Exception):
+                # log stacktrace if message is an exception
+                self._logger._log(ERROR, message, (), exc_info=True)
+            else:
+                self._logger._log(ERROR, message, ())
+
+    @property
+    def in_debug_mode(self) -> bool:
+        """Checks if the logger's level is DEBUG
+
+        Returns
+        -------
+        bool
+            True, if logger is in DEBUG mode, False otherwise
+        """
+        return self._logger.level == DEBUG
+
+    @property
+    def level(self) -> int:
+        """Returns the current log level
+
+        Returns
+        -------
+        int
+            Log level.
+        """
+        return self._logger.level
+
+    def __repr__(self):
+        return f"<Logger: {self.name} ({self.level})>"
+
+
+def get_logger(name: str) -> logging.Logger:
+    """Gets the specified logger object
+
+    Parameters
+    ----------
+    name : str
+        Name of the module to get the logger for
+
+    Returns
+    -------
+    logging.Logger
+        Logger of the specified module
+    """
+    return logging.getLogger(name)
+
+
+def logger_exists(name: str) -> bool:
+    """Checks if a logger exists for the specified module
+
+    Parameters
+    ----------
+    name : str
+        Name of the module to check the logger for
+
+    Returns
+    -------
+    bool
+        True if logger exists, False otherwise
+    """
+    return logging.getLogger(name).hasHa
+    ndlers()
+
+
+def set_level(name: str, level: int | str):
+    """Sets log level for the specified logger
+
+    Parameters
+    ----------
+    name : str
+        Name of the module
+    level : int | str
+        Level to set
+    """
+    logger = logging.getLogger(name)
+
+    # translate string to integer
+    if isinstance(level, str):
+        level = LEVELS[level.upper()]
+
+    # set the logger's level
+    logger.setLevel(level)
+
+    # and all handlers
+    for handler in logger.handlers:
+        handler.setLevel(level)
+
+        # optionally change the formatter (log more when in debug mode)
+        if level < INFO:
+            handler.setFormatter(DEBUG_FORMAT)
+        else:
+            handler.setFormatter(DEFAULT_FORMAT)
+
+
+def set_verbosity(level: int):
+    """Sets verbosity to the given level
+
+    Parameters
+    ----------
+    level : int
+        Logg only errors (0), info (1) or even debug messages (2)
+    """
+    if level == 0:
+        set_level("chaine._core.crf", "ERROR")
+        set_level("chaine.crf", "ERROR")
+    elif level == 1:
+        set_level("chaine._core.crf", "INFO")
+        set_level("chaine.crf", "INFO")
+    elif level == 2:
+        set_level("chaine._core.crf", "DEBUG")
+        set_level("chaine.crf", "DEBUG")

chaine/optimization/__init__.py

@@ -0,0 +1,10 @@
+from chaine.optimization import utils
+from chaine.optimization.spaces import (
+    APSearchSpace,
+    AROWSearchSpace,
+    L2SGDSearchSpace,
+    LBFGSSearchSpace,
+    PASearchSpace,
+    SearchSpace,
+)
+from chaine.optimization.trial import OptimizationTrial

chaine/optimization/metrics.py

@@ -0,0 +1,129 @@
+"""
+chaine.optimization.metrics
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+This module implements metrics to evaluate the performance of a trained model.
+"""
+
+from collections import Counter
+
+
+def calculate_precision(true_positives: int, false_positives: int) -> float:
+    """Calculate precision score.
+
+    Parameters
+    ----------
+    true_positives : int
+        Number of true positives.
+    false_positives : int
+        Number of false positives.
+
+    Returns
+    -------
+    float
+        Precision score.
+    """
+    try:
+        return true_positives / (true_positives + false_positives)
+    except ZeroDivisionError:
+        # only false negatives is perfect precision
+        return 1.0
+
+
+def calculate_recall(true_positives: int, false_negatives: int) -> float:
+    """Calculate recall score.
+
+    Parameters
+    ----------
+    true_positives : int
+        Number of true positives.
+    false_negatives : int
+        Number of false negatives.
+
+    Returns
+    -------
+    float
+        Recall score.
+    """
+    try:
+        return true_positives / (true_positives + false_negatives)
+    except ZeroDivisionError:
+        # only false positives is imperfect recall
+        return 0.0
+
+
+def calculate_f1(true_positives: int, false_positives: int, false_negatives: int) -> float:
+    """Calculate F1 score.
+
+    Parameters
+    ----------
+    true_positives : int
+        Number of true positives.
+    false_negatives : int
+        Number of false negatives.
+
+    Returns
+    -------
+    float
+        Precision score
+    """
+    precision = calculate_precision(true_positives, false_positives)
+    recall = calculate_recall(true_positives, false_negatives)
+    try:
+        return (2 * precision * recall) / (precision + recall)
+    except ZeroDivisionError:
+        # zero precision and zero recall is zero f1
+        return 0.0
+
+
+def evaluate_predictions(true: list[list[str]], pred: list[list[str]]) -> dict[str, float]:
+    """Evaluate the given predictions with the true labels.
+
+    Parameters
+    ----------
+    true : list[list[str]]
+        True labels.
+    pred : list[list[str]]
+        Predicted labels.
+
+    Returns
+    -------
+    dict[str, float]
+        Precision, recall and F1 scores.
+    """
+    # validate input
+    if (
+        not isinstance(true, list)
+        or not isinstance(pred, list)
+        or not isinstance(true[0], list)
+        or not isinstance(pred[0], list)
+    ):
+        raise ValueError("Input lists are invalid")
+
+    counts = Counter()
+
+    # get true positives, true negatives, false positives, false negatives
+    for true_labels, predicted_labels in zip(true, pred):
+        # ignore prefixes
+        true_labels = [l.removeprefix("B-").removeprefix("I-") for l in true_labels]
+        predicted_labels = [l.removeprefix("B-").removeprefix("I-") for l in predicted_labels]
+
+        if len(true_labels) != len(predicted_labels):
+            raise ValueError(f"Different lengths: '{true_labels}' vs. '{predicted_labels}'")
+
+        for true_label, predicted_label in zip(true_labels, predicted_labels):
+            if true_label != "O" and predicted_label == true_label:
+                counts["tp"] += 1
+            if predicted_label != "O" and predicted_label != true_label:
+                counts["fp"] += 1
+            if true_label == "O" and predicted_label == "O":
+                counts["tn"] += 1
+            if true_label != "O" and predicted_label == "O":
+                counts["fn"] += 1
+
+    # calculate precision, recall and f1 score
+    return {
+        "precision": calculate_precision(counts["tp"], counts["fp"]),
+        "recall": calculate_recall(counts["tp"], counts["fn"]),
+        "f1": calculate_f1(counts["tp"], counts["fp"], counts["fn"]),
+    }