HOBIT 1.0.0__py3-none-any.whl

HOBIT/HOBIT.py

@@ -0,0 +1,71 @@
+import numpy as np
+import logging
+import optuna
+from sklearn.base import BaseEstimator, TransformerMixin
+from sklearn.linear_model import LinearRegression
+
+optuna.logging.set_verbosity(optuna.logging.WARNING)
+
+
+class RegressionForTrigonometric(BaseEstimator, TransformerMixin):
+    def __init__(self, omega_range=(0, 10), phi_range=(-np.pi, np.pi)):
+        self.omega_range = omega_range
+        self.phi_range = phi_range
+        self.model = LinearRegression()
+        self.best_parameters = {}
+
+    def opt_trig_params(self, X, y, **kwargs):
+        # Accept max_evals (legacy hyperopt name) or n_trials (optuna name)
+        n_trials = kwargs.pop('max_evals', kwargs.pop('n_trials', 100))
+
+        def objective(trial):
+            omega = trial.suggest_float('omega', self.omega_range[0], self.omega_range[1])
+            phi = trial.suggest_float('phi', self.phi_range[0], self.phi_range[1])
+            return float(np.mean((self.a0 + self.a1 * self.trig_func(omega * X + phi) - y) ** 2))
+
+        logging.debug('Performing TPE algorithm to find optimal omega and phi')
+        study = optuna.create_study(direction='minimize', sampler=optuna.samplers.TPESampler())
+        study.optimize(objective, n_trials=n_trials)
+        return study.best_params
+
+    def _fit_trig_params(self, X, y, **kwargs):
+        self.a1 = (y.max() - y.min()) / 2.
+        self.a0 = y.mean()
+        trig_params = self.opt_trig_params(X, y, **kwargs)
+        self.best_parameters = trig_params
+
+    def _transform_params(self, X):
+        omega = self.best_parameters['omega'] * np.ones(len(X))
+        phi = self.best_parameters['phi'] * np.ones(len(X))
+        x_new = self.trig_func(omega * X + phi)
+        x_new = x_new[:, np.newaxis]
+        return x_new
+
+    def _fit(self, X, y, trig_func='cos', **kwargs):
+        if trig_func == 'cos':
+            self.trig_func = np.cos
+        elif trig_func == 'sin':
+            self.trig_func = np.sin
+        else:
+            raise Exception('trig_func must be sin or cos.')
+
+        self._fit_trig_params(X, y, **kwargs)
+        X_transf = self._transform_params(X)
+        self.model.fit(X_transf, y)
+        self.best_parameters['intercept'] = self.model.intercept_
+        self.best_parameters['amplitude'] = self.model.coef_[0]
+        return self
+
+    def predict(self, X):
+        X_transf = self._transform_params(X)
+        ypred = self.model.predict(X_transf)
+        return ypred
+
+    def fit_sin(self, X, y, **kwargs):
+        if self.phi_range == (-np.pi, np.pi):
+            logging.debug('The defined domain of Sine function is (0, 2*pi)')
+            self.phi_range = (0, 2 * np.pi)
+        return self._fit(X, y, trig_func='sin', **kwargs)
+
+    def fit_cos(self, X, y, **kwargs):
+        return self._fit(X, y, trig_func='cos', **kwargs)

HOBIT/__init__.py

@@ -0,0 +1 @@
+from .HOBIT import *

hobit-1.0.0.dist-info/METADATA

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: HOBIT
+Version: 1.0.0
+Summary: an installable package for Hybrid fitting of Sine and Cosine functions
+Author: Jose Arturo Celis Gil
+Author-email: solocelis@gmail.com
+Requires-Python: >=3.11
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: numpy (>=1.26.0)
+Requires-Dist: optuna (>=3.0.0)
+Requires-Dist: pandas (>=2.0.0)
+Requires-Dist: scikit-learn (>=1.4.0)
+Project-URL: Homepage, https://github.com/Harmonic-Oscillator-hyBrid-fIT/HOBIT
+Description-Content-Type: text/markdown
+
+<p align="center">
+ <img src="https://github.com/anamabo/HOBIT/blob/master/images/logo.png?raw=true" alt="Sublime's custom image"/>
+</p>
+
+# HOBIT: Harmonic Oscillator hyBrid fIT
+## Efficient fit of sine/cosine functions using a hybrid method
+### Read our [blog](https://towardsdatascience.com/fitting-cosine-sine-functions-with-machine-learning-in-python-610605d9b057)
+
+HOBIT is a Python library that combines [Optuna](https://optuna.org/)'s TPE algorithm with the flexibility of scikit-learn's `LinearRegression` to efficiently fit functions of the form
+
+```
+f(x) = y_0 + y_1 * Sin(omega * x + phi)
+f(x) = y_0 + y_1 * Cos(omega * x + phi)
+```
+
+commonly used to describe harmonic oscillators.
+
+## Install
+
+```
+pip install HOBIT
+```
+
+### Requirements
+
+HOBIT requires Python >= 3.11 and will install the following dependencies:
+
+* `pandas >= 2.0.0`
+* `numpy >= 1.26.0`
+* `optuna >= 3.0.0`
+* `scikit-learn >= 1.4.0`
+
+## Get started
+
+In the `test_scripts/` folder you will find the following examples:
+
+1. `scipy_and_gradient_descent.py` — fit of a cosine function using scipy's `curve_fit` and a walkthrough of gradient descent.
+2. `only_optuna.py` — fit of a cosine function using Optuna's TPE sampler directly.
+3. `hybrid_method_cos.py` — fit of a cosine function using HOBIT.
+4. `hybrid_method_sin.py` — fit of a sine function using HOBIT.
+
+### Quick example
+
+```python
+import numpy as np
+from HOBIT import RegressionForTrigonometric
+
+x = np.linspace(-5, 5, 100)
+y = 10 + 5 * np.cos(3 * x + 2) + 1.5 * np.random.normal(size=100)
+
+model = RegressionForTrigonometric()
+model.fit_cos(x, y, n_trials=500)
+
+print(model.best_parameters)
+# {'omega': ..., 'phi': ..., 'intercept': ..., 'amplitude': ...}
+
+y_pred = model.predict(x)
+```

hobit-1.0.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+HOBIT/HOBIT.py,sha256=x4n-2eT4qVev1U7zKEgyNI6olzt101NUFmwS2rybYnc,2793
+HOBIT/__init__.py,sha256=jXrtlbeEg0FfjKGzZeoP1hjs_IqkkuRSq0fJju10Oys,21
+hobit-1.0.0.dist-info/METADATA,sha256=LCJVhUK-3V7zdeQA-VA9fcXDr51wgvusu-evbg4EaTQ,2505
+hobit-1.0.0.dist-info/WHEEL,sha256=EGEvSphFYqXKs23-kQBeyNoJP1nrT8ZJKQoi5p5DYL8,88
+hobit-1.0.0.dist-info/RECORD,,

hobit-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.4.0
+Root-Is-Purelib: true
+Tag: py3-none-any