Metadata-Version: 2.1
Name: embarrassingly
Version: 0.0.6
Summary: Pimp your objective function for faster, robust optimization
Home-page: https://github.com/microprediction/embarrassingly
Author: microprediction
Author-email: pcotton@intechinvestments.com
License: MIT
Platform: UNKNOWN
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.7
Description-Content-Type: text/markdown
Requires-Dist: wheel
Requires-Dist: pathlib
Requires-Dist: numpy
Requires-Dist: scipy
Requires-Dist: scikit-learn
Requires-Dist: smt
Requires-Dist: tdigest
Requires-Dist: optuna
Requires-Dist: deap
Requires-Dist: microprediction
Requires-Dist: pandas

# embarrassingly

Embarrassingly obvious (in retrospect) ways to hack objective functions before you send them to optimization routines. 
See [blog article](https://www.microprediction.com/blog/robust-optimization) for motivation and explanation

![](https://i.imgur.com/pvcS5AX.png)

### Install 

    pip install embarrassingly 

### Example 1 : Parallel objective computation 

See [optuna_parallel.py](https://github.com/microprediction/embarrassingly/blob/main/examples/optuna_parallel.py)

    from embarrassingly.parallel import Parallel
    import optuna

    def pre_objective(worker, trial):
        print('Hi this is worker ' + str(worker))
        x = [trial.suggest_float('x' + str(i), 0, 1) for i in range(3)]
        return x[0] + x[1] * x[2]

    def test_optuna():
        objective = Parallel(pre_objective, num_workers=7)
        study = optuna.create_study()
        study.optimize(objective, n_trials=15, n_jobs=7)

### Example 2 : Plateau finding

See [underpromoted_shgo.py](https://github.com/microprediction/embarrassingly/blob/main/examples/underpromoted_shgo.py)

    from scipy.optimize import shgo
    from embarrassingly.underpromoted import plateaudinous, Underpromoted2d

    bounds = [(-1 ,1) ,(-1 ,1)]
    f = plateaudinous
    res1 = shgo(func=f, bounds=bounds, n=8, iters=4, options={'minimize_every_iter': True, 'ftol': 0.1})
    print('Minimum at '+str(res1.x))

    f_tilde = Underpromoted2d(f, bounds=bounds, radius=0.05)
    res1 = shgo(func=f_tilde, bounds=bounds, n=8, iters=4, options={'minimize_every_iter': True, 'ftol': 0.1})
    print('Landed at '+str(res1.x))



### Example 3 : Expensive functions 

See [shy_shgo.py](https://github.com/microprediction/embarrassingly/blob/main/examples/shy_shgo.py)

    def slow_and_pointless(x):
    """ Example of a function with varying computation time """
        r = np.linalg.norm(x)
        quad = (0.5*0.5-r*r)/(0.5*0.5)
        compute_time = max(0,0.5*quad+x[0])
        time.sleep(compute_time)
        return schwefel([1000*x[0],980*x[1]])[0]

    # Save time by making it a "shy" objective function
    bounds = [(-0.5, 0.5), (-0.5, 0.5)]
    SAP = Shy(slow_and_pointless, bounds=bounds, t_unit=0.01, d_unit=0.3)
    from scipy.optimize import minimize
    res = scipy.optimize.shgo(func=SAP, bounds=bounds, n=8, iters=4, options={'minimize_every_iter': True, 'ftol': 0.1})



