Metadata-Version: 2.2
Name: omle-runtime
Version: 0.1.0rc5
Summary: OMLE inference runtime — fast classical ML inference
Keywords: machine-learning,inference,scikit-learn,onnx,runtime
Author: OMLE contributors
License: Apache-2.0
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: Science/Research
Classifier: License :: OSI Approved :: Apache Software License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Python :: 3.13
Classifier: Programming Language :: Python :: 3.14
Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
Classifier: Programming Language :: C++
Project-URL: Homepage, https://github.com/openmle/omle-runtime
Project-URL: Source, https://github.com/openmle/omle-runtime
Project-URL: Issues, https://github.com/openmle/omle-runtime/issues
Requires-Python: >=3.10
Requires-Dist: numpy
Provides-Extra: dev
Requires-Dist: pytest; extra == "dev"
Requires-Dist: pandas; extra == "dev"
Description-Content-Type: text/markdown

# omle-runtime

Fast inference for classical ML models, with a scikit-learn-style API.

`omle-runtime` loads `.omle` models and scores them through a native C++ runtime
with pybind11 bindings. Wheels are self-contained — protobuf and Abseil are
linked in statically, so there is nothing to install alongside.

```python
import numpy as np
import omle_runtime as omr

model = omr.load("model.omle", n_threads=4)   # thread-safe
X = np.random.randn(1000, 10).astype(np.float32)

scores = model.predict(X)         # (n_samples,)
proba  = model.predict_proba(X)   # (n_samples, n_outputs)
```

`Model` implements the scikit-learn estimator interface (`predict`,
`predict_proba`, `fit`, `get_params`, `set_params`, `n_features_in_`,
`feature_names_in_`), so it can be the final step of a `Pipeline`:

```python
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

pipe = Pipeline([("scaler", StandardScaler()), ("model", model)])
pipe.predict(X)
```

For repeated scoring on a thread, create a session once and reuse it:

```python
session = model.create_session()   # one per thread
scores = session.predict(X)
```

## Related packages

- [`omle`](https://pypi.org/project/omle/) — the model IR and converters
- [`omle-spark`](https://pypi.org/project/omle-spark/) — PySpark transformer

## License

Apache-2.0
