lan
landscapes
pypi i landscapes
lan

landscapes

A dependency free library of standardized optimization test functions written in pure Python.

by Nathan Rooy

0.0.12 (see all)
pypi i landscapes
Readme

gh-actions-ci GitHub license PyPI pyversions PyPi Version codecov Downloads

Installation

There are a couple ways in which you can use this library. The first and probably the easiest is by using pip and PyPi:

pip install landscapes

You can also install directly from this git repo:

pip install git+https://github.com/nathanrooy/landscapes

Lastly, you can always clone/download this repo and use as is.

wget https://github.com/nathanrooy/landscapes/archive/master.zip
unzip master.zip
cd landscapes-master

Available functions from: single_objective

function namemethoddimensions
Ackleyackley()2
Ackley N.2ackley_n2()2
Adjimanadjiman()2
AMGMamgm()n
Bartels Connbartels_conn()2
Birdbird()2
Bealebeale()2
Bent Cigarbent_cigar()n
Bohachevsky N.1bohachevsky_n1()2
Bohachevsky N.2bohachevsky_n2()2
Bohachevsky N.3bohachevsky_n3()2
Boothbooth()2
Braninbranin()2
Brentbrent()2
Brownbrown()n
Bukin n6bukin_n6()2
3-Hump Camelcamel_hump_3()2
6-Hump Camelcamel_hump_6()2
Carrom Tablecarrom_table()2
Chichinadzechichinadze()2
Chung Reynoldschung_reynolds()n
Colvillecolville()4
Cosine Mixturecosine_mixture()n
Cross-in-Traycross_in_tray()2
Csendescsendes()n
Cubecube()2
Damavandidamavandi()2
Deckkers-Aartsdeckkers_aarts()2
Dixon & Pricedixon_price()n
Drop Wavedrop_wave()2
Easomeasom()2
Eggholdereggholder()2
Exponentialexponential()n
Freudenstein Rothfreudenstein_roth()2
Goldstein–Pricegoldstein_price()2
Griewankgriewank()n
Himmelblauhimmelblau()2
Hölder tableholder_table()2
Hosakihosaki()2
Keanekeane()2
Leonleon()2
Lévi function N.13levi_n13()2
Matyasmatyas()2
Michalewiczmichalewiczn
McCormickmccormick()2
Parsopoulosparsopoulos()2
Pen Holderpen_holder()2
Plateauplateau()n
Qingqing()n
Quarticquartic()n
Rastriginrastrigin()n
Rotated Hyper-Ellipsoidrotated_hyper_ellipsoid()n
Rosenbrockrosenbrock()n
Salomonsalomon()n
Schaffer N.2schaffer_n2()2
Schaffer N.4schaffer_n4()2
Schwefelschwefel()n
Spheresphere()n
Stepstep()n
Styblinski–Tangstyblinski_tang()n
Sum of Different Powerssum_of_different_powers()n
Sum of Squaressum_of_squares()n
Tridtrid()n
Tripodtripod()2
Wolfewolfe()3
Zakharovzakharov()n

Usage

As a simple example, let's use the Nelder-Mead method via SciPy to minimize the sphere function. We'll start off by importing the sphere function from Landscapes and the minimize method from SciPy.

>>> from landscapes.single_objective import sphere
>>> from scipy.optimize import minimize

Next, we'll call the minimize method using a starting location of [5,5].

>>> minimize(sphere, x0=[5,5], method='Nelder-Mead')

The output of which should look close to this:

 final_simplex: (array([[-3.33051318e-05, -1.93825710e-05],
       [ 4.24925225e-05,  1.37129516e-05],
       [ 3.09383247e-05, -4.04797876e-05]]), array([1.48491586e-09, 1.99365951e-09, 2.59579314e-09]))
           fun: 1.4849158640215086e-09
       message: 'Optimization terminated successfully.'
          nfev: 80
           nit: 44
        status: 0
       success: True
             x: array([-3.33051318e-05, -1.93825710e-05])

Function Reference - Single Objective

Ackley function

from landscapes.single_objective import ackley
global minimumboundsusage
f(x=0,y=0)=0-5.12 <= x, y <= 5.12ackley([x,y])

Beale function

from landscapes.single_objective import beale
global minimumboundsusage
f(x=3, y=0.5) = 0-4.5 <= x, y <= 4.5beale([x,y])

Booth function

from landscapes.single_objective import booth
global minimumboundsusage
f(x=1, y=3) = 0-10 <= x, y <= 10booth([x,y])

Bukin N.6 function

from landscapes.single_objective import bukin_n6
global minimumboundsusage
f(x=-10, y=1) = 0-15 <= x <= -5
-3 <= y <= 3
bukin_n6([x,y])

Cross-in-tray function

from landscapes.single_objective import cross_in_tray
global minimum(s)boundsusage
f(x=1.34941, y=-1.34941) = -2.06261
f(x=1.34941, y=1.34941) = -2.06261
f(x=-1.34941, y=1.34941) = -2.06261
f(x=-1.34941, y=-1.34941) = -2.06261
-10 <= x, y <= 10cross_in_tray([x,y])

Easom function

from landscapes.single_objective import easom
global minimumboundsusage
f(x=pi, y=pi) = -1-100 <= x, y <= 100easom([x,y])

Eggholder function

from landscapes.single_objective import eggholder
global minimumboundsusage
f(x=512, y=404.2319) = -959.6407-512 <= x, y <= 512eggholder([x,y])

Goldstein–Price function

from landscapes.single_objective import goldstein_price
global minimumboundsusage
f(x=0, y=-1) = 3-2 <= x, y <= 2goldstein_price([x,y])

Himmelblau's function

from landscapes.single_objective import himmelblau
global minimum(s)boundsusage
f(x=3.0, y=2.0) = 0.0
f(x=-2.805118, y=3.131312) = 0.0
f(x=-3.779310, y=-3.283186) = 0.0
f(x=3.584428, y=-1.848126) = 0.0
-5 <= x, y <= 5himmelblau([x,y])

Hölder table function

from landscapes.single_objective import holder_table
global minimum(s)boundsusage
f(x=8.05502, y=9.66459) = -19.2085
f(x=-8.05502, y=9.66459) = -19.2085
f(x=8.05502, y=-9.66459) = -19.2085
f(x=-8.05502, y=-9.66459) = -19.2085
-10 <= x, y <= 10holder_table([x,y])

Lévi function N.13

from landscapes.single_objective import levi_n13
global minimumboundsusage
f(x=1, y=1) = 0-10 <= x, y <= 10levi_n13([x,y])

Matyas function

from landscapes.single_objective import matyas
global minimumboundsusage
f(x=0, y=0) = 0-10 <= x, y <= 10matyas([x,y])

McCormick function

from landscapes.single_objective import mccormick
global minimumboundsusage
f(x=-0.54719, y=-1.54719) = -1.9133-1.5 <= x <= 4
-3 <= y <= 4
mccormick([x,y])

Rastrigin function

from landscapes.single_objective import rastrigin
global minimumboundsusage
f([0,...,0]) = 0-5.12 <= x_i <= 5.12rastrigin([x_1,...,x_n])

Rosenbrock function

from landscapes.single_objective import rosenbrock
global minimumboundsusage
f([1,...,1]) = 0-inf <= x_i <= infrosenbrock([x_1,...,x_n])

Schaffer function N.2

from landscapes.single_objective import schaffer_n2
global minimumboundsusage
f(x=0, y=0) = 0-100 <= x, y <= 100schaffer_n2([x,y])

Schaffer function N.4

from landscapes.single_objective import schaffer_n4
global minimumboundsusage
f(x=0, y=1.25313) = 0.292579
f(x=0, y=-1.25313) = 0.292579
-100 <= x, y <= 100schaffer_n4([x,y])

Sphere function

from landscapes.single_objective import sphere
global minimumboundsusage
f([0,...,0]) = 0-inf <= x_i <= infsphere([x_1,...x_n])

Styblinski–Tang function

from landscapes.single_objective import styblinski_tang
global minimumboundsusage
-39.16617n < f([-2.903534,...,-2.903534]) < -39.16616n-5 <= x_i <= 5styblinski_tang([x_1,...x_n])

Three-hump camel function

from landscapes.single_objective import camel_hump_3
global minimumboundsusage
-f(x=0, y=0) = 0-5 <= x_i <= 5three_hump_camel([x,y])

Travelling salesman problem (TSP)

from landscapes.single_objective import tsp

There are several ways to use the TSP function within Landscapes, all of which involve specifying a list of tsp stops, and a distance function.

Example 1: Multi-dimensional list of points using Euclidean distance function

from landscapes.single_objective import tsp
from scipy.spatial import distance

np.random.seed(10)
pts = np.random.rand(5,3)

which will yield a list of three-dimensional points:

array([[0.77132064, 0.02075195, 0.63364823],
       [0.74880388, 0.49850701, 0.22479665],
       [0.19806286, 0.76053071, 0.16911084],
       [0.08833981, 0.68535982, 0.95339335],
       [0.00394827, 0.51219226, 0.81262096]])

Then, initialize the tsp function:

tsp_cost = tsp(distance.euclidean, close_loop=True).dist

To calculate the total travel distance, simply call the function with the list of points:

tsp_cost(pts)
>>> 3.2043803044101096

The flag close_loop simply specifies whether the distance between the first and last points should be calculated.

Example 2: Specifying points using Latitude and Longitude

Insead of multi-dimensional points in space, let's specify a list of locations based on longitude and latitude then calculate the distances using the inverse Vincenty's formulae which is available in the spatial package [here].

First let's import our Vincenty based distance function and wrap it for easier use.

from spatial import vincenty_inverse as vi

def vi_tsp(p1, p2):
    return vi(p1, p2).mi() # output distance in miles

Next, let's specify some locations. Here are some breweries in Cincinnati. Each row represents a [longitude, latitude].

pts = [
    [-84.508661, 39.110187],
    [-84.520021, 39.117219],
    [-84.514938, 39.113937],
    [-84.517401, 39.111322],
    [-84.476906, 39.128957]]

Again, initialize the tsp function:

tsp_cost = tsp(vi_tsp, close_loop=True).dist

And finally, calculate the travel distance:

tsp_cost(pts)
>>> 5.993331331465468

Example #3: Geospatial distances on a graph

In Example #2 we used Vincenty's inverse formulae which calculates the distance between two longitude and latitude pairs "as the crow flies". That's great for some situations, but in a city where we're limited by streets and sidewalks, it's a little less useful. Instead, what we want is the actual distance if we were going to walk or bike. This is the network distance and is only slighly more complex, but involves some additinal libraries.

First, import the dependencies:

import osmnx as ox
import networkx as nx
import pandas as pd

Next, load the brewery locations (available here) and prepare the Open Street Map (OSM) network graph.

pts_df = pd.read_csv('brewery_locations.csv')

# determine bounds for osm network
lats = locs_df['lat'].values
lngs = locs_df['lng'].values

bbox = [
    max(lats) + 0.1,
    min(lats) - 0.1,
    max(lngs) + 0.1,
    min(lngs) - 0.1]

# download osm street network
G = ox.graph_from_bbox(bbox[0], bbox[1], bbox[2], bbox[3], network_type='drive')

Downloading the osm graph might take a bit depending on internet speed. Next, let's create a new cost function that takes in two brewery names and returns the network distance in meters.

def osm_dist(n0, n1):
    p0 = pts_df[pts_df['name']==n0][['lat','lng']].values[0]
    p1 = pts_df[pts_df['name']==n1][['lat','lng']].values[0]

    p0_node = ox.get_nearest_node(G, p0)
    p1_node = ox.get_nearest_node(G, p1)

    dist_m = nx.shortest_path_length(G, p0_node, p1_node, weight='length')
    return dist_m

Again, specify the tsp cost function:

tsp_cost = tsp(osm_dist, close_loop=True).dist

And to get the network distance:

tsp_cost(locs_df['name'].values)
>>> 75950.73399999998

This translates to roughly 47 miles.

LAST COMMIT

2yrs ago

MAINTAINERS

1

CONTRIBUTORS

4

OPEN ISSUES

0

OPEN PRs

0
VersionTagPublished
0.0.12
2yrs ago
0.0.11
2yrs ago
0.0.10
2yrs ago
0.0.8
2yrs ago
No alternatives found

Rate & Review

100
No reviews found
Be the first to rate