moocore

0.2.0 · active · verified Wed Apr 15

moocore provides fast implementations of core mathematical functions and algorithms for multi-objective optimization. While available in R, this entry focuses on the Python package (v0.2.0). It offers functionalities for generating and transforming non-dominated sets, identifying dominated vectors, and computing various quality metrics like hypervolume and epsilon indicator. The critical functionality is implemented in C for high performance. The project maintains a frequent release cadence, often with minor updates.

Warnings

gotcha Performance vs. Numerical Precision: `moocore` prioritizes speed through C implementations, which might lead to minor numerical differences compared to other multi-objective optimization libraries that use different underlying algorithms or floating-point precision strategies. Users migrating from other libraries should verify results for critical applications.
Fix: Thoroughly test `moocore`'s output against your established benchmarks or reference implementations, especially for edge cases or when high numerical precision is paramount. Consult the documentation for algorithm specifics.
breaking C-Core Error Handling: Older versions might terminate abruptly due to `exit()` or `abort()` calls within the C core instead of raising Python exceptions. While there are ongoing efforts to improve this, users might encounter unexpected program termination instead of catchable Python errors in some scenarios.
Fix: Ensure your C/C++ compiler is up-to-date if building from source. For installed versions, check GitHub issues for updates on C-core error handling. Isolate `moocore` calls in `try-except` blocks to handle potential exceptions, though abrupt termination may still bypass this for some unhandled C-level errors.
gotcha Implicit NumPy Dependency: Although `numpy` is not a strict PyPI dependency, most examples and practical usage patterns for data handling within `moocore` implicitly rely on `numpy` arrays. Directly passing Python lists to certain functions may lead to performance overhead or unexpected behavior if not properly handled internally.
Fix: Always convert input data to `numpy` arrays before passing them to `moocore` functions, e.g., `data = np.asarray(your_list_of_points)`. Explicitly install `numpy` in your environment (`pip install numpy`).
gotcha Lack of Explicit Breaking Change Notes for 0.2.0: Despite incrementing the minor version from 0.1.x to 0.2.0, no explicit breaking changes were highlighted in the release notes. Users upgrading from 0.1.x versions should exercise caution and thoroughly test their applications, as underlying algorithm changes or interface adjustments might have occurred without explicit documentation.
Fix: Review the full changelog on GitHub, examine the `git diff` between versions if possible, and run comprehensive regression tests on your code when upgrading from any 0.1.x version to 0.2.0 or newer.

Install

pip install moocore Install latest PyPI version

Imports

moocore
```
import moocore
```

filter_dominated

import moocore
points = moocore.filter_dominated(data)

Hypervolume

import moocore
hv_calculator = moocore.Hypervolume(reference=ref_point)

Quickstart

This quickstart demonstrates basic usage of moocore for identifying and filtering non-dominated points and calculating the hypervolume indicator. It assumes a minimization problem for all objectives. The `moocore.is_nondominated` function returns a boolean mask, while `moocore.filter_dominated` directly returns the non-dominated points. The `moocore.Hypervolume` class is initialized with a reference point and then called with the set of points.

import numpy as np
import moocore

# Example data: a set of 2D points (assuming minimization)
# Each row is a point, each column is an objective
data = np.array([
    [1.0, 5.0],
    [2.0, 3.0],
    [3.0, 2.0],
    [4.0, 1.0],
    [2.5, 2.5],
    [1.5, 4.0]
])

# 1. Identify non-dominated points
nondominated_points_mask = moocore.is_nondominated(data)
nondominated_set = data[nondominated_points_mask]
print(f"Non-dominated points:\n{nondominated_set}")

# 2. Filter dominated points (returns only non-dominated ones)
filtered_set = moocore.filter_dominated(data)
print(f"Filtered (non-dominated) set:\n{filtered_set}")

# 3. Calculate Hypervolume (requires a reference point)
# Reference point should be worse than all points in the objective space
# For minimization, this means typically larger values.
ref_point = np.array([5.0, 5.0]) # Example reference point

hv_calculator = moocore.Hypervolume(reference=ref_point)
hypervolume_value = hv_calculator(filtered_set)
print(f"Hypervolume of the non-dominated set: {hypervolume_value}")

view raw JSON →