josiann.vsa
- josiann.vsa(fun, x0, args=None, bounds=None, moves=((0.8, [Move] RandomStep(0.05)), (0.2, [Move] RandomStep(0.5))), nb_walkers=1, max_iter=200, max_measures=20, final_acceptance_probability=1e-300, epsilon=0.01, T_0=5.0, tol=0.001, vectorized_on_evaluations=True, vectorized_skip_marker=None, backup=False, nb_slots=None, seed=None, verbose=True, suppress_warnings=False, detect_convergence=True, window_size=None, dtype=<class 'numpy.float64'>)[source]
Simulated Annealing using vectorized cost functions for computing multiple function evaluations at once.
- Parameters:
fun (
Callable
[...
,list
[float
]]) – a <d> dimensional (noisy) function to minimize.x0 (
ndarray
[Any
,dtype
[Any
]]) – a <d> dimensional vector of initial values.args (
Optional
[tuple
[Any
,...
]] (default:None
)) – an optional sequence of arguments to pass to the function to minimize.bounds (
Optional
[Sequence
[tuple
[float
,float
]]] (default:None
)) – an optional sequence of bounds (one for each <n> dimensions) with the following format: (lower_bound, upper_bound) or a single (lower_bound, upper_bound) tuple of bounds to set for all dimensions.moves (
Union
[Move
,Sequence
[Move
],Sequence
[tuple
[float
,Move
]]] (default:((0.8, [Move] RandomStep(0.05)), (0.2, [Move] RandomStep(0.5)))
)) –a single josiann.Move object
- a sequence of josiann.Move objects (all Moves have the same probability of being selected at each step
for proposing a new candidate vector x)
- a sequence of tuples with the following format(selection probability, josiann.Move)
In this case, the selection probability dictates the probability of each Move of being selected at each step.
nb_walkers (
int
(default:1
)) – the number of parallel walkers in the ensemble.max_iter (
int
(default:200
)) – the maximum number of iterations before stopping the algorithm.max_measures (
int
(default:20
)) – the maximum number of function evaluations to average per step.final_acceptance_probability (
float
(default:1e-300
)) – the targeted final acceptance probability at iteration <max_iter>.epsilon (
float
(default:0.01
)) – parameter in (0, 1) for controlling the rate of standard deviation decrease (bigger values yield steeper descent profiles)T_0 (
float
(default:5.0
)) – initial temperature value.tol (
float
(default:0.001
)) – the convergence tolerance.vectorized_on_evaluations (
bool
(default:True
)) –the vectorization can happen on walkers or on function evaluations.
- On function evaluations, a loop on walkers calls <fun> with a vector of positions of the walker, repeated
for the number of needed function evaluations. Ex: 2 walkers with position vectors p1 and p2 each need n1 and n2 function evaluations. <fun> is first called for walker 1 with a vector (p1, p1, …, p1) of size n1, then <fun> is called for walker 2 with a vector (p2, p2, …, p2) of size n2. This is the default option and is valid when <fun> is ok with receiving vectors of varying length and when <max_measures> is greater than <nb_walkers>.
- On walkers, a loop on function evaluations calls <fun> with a vector of fixed size = <nb_walkers>.
Ex: 2 walkers with position vectors p1 and p2 each need n1 and n2 function evaluations. <fun> is called with vector (p1, p2) for max(n1, n2) times. Often, n1 =/= n2 which would yield unnecessary function evaluations (e.g. when n1 < n2, some evaluations of p1 are not needed while p2 is still evaluated). To indicated that to <fun>, the <vectorized_skip_marker> is passed instead of unnecessary position vectors (e.g. when n1 < n2, the vector passed to <fun> will eventually be (<vectorized_skip_marker>, p2) instead of (p1, p2)). This is valid when <fun> needs to receive vectors of fixed length and when <nb_walkers> is greater than <max_measures>.
vectorized_skip_marker (
Optional
[Any
] (default:None
)) – when vectorizing on walkers, the object to pass to <fun> to indicate that an evaluation for a particular position vector can be skipped.backup (
bool
(default:False
)) – use Backup for storing previously computed function evaluations and reusing them when returning to the same position vector ? (Only available when using SetStep moves).nb_slots (
Optional
[int
] (default:None
)) – When using a vectorized function, the total number of position vectors for which the cost can be computed at once. For example, when using 5 walkers and 22 slots, each walker will be attributed respectively 5, 5, 4, 4, and 4 slots. Multiple slots per walker are used for exploring multiple possible moves from the starting position vector of each walker, increasing convergence speed.seed (
Optional
[int
] (default:None
)) – a seed for the random generator.verbose (
bool
(default:True
)) – print progress bar ?suppress_warnings (
bool
(default:False
)) – remove warnings ?detect_convergence (
bool
(default:True
)) – run convergence detection for an early stop of the algorithm ?window_size (
Optional
[int
] (default:None
)) – number of past iterations to look at for detecting the convergence, getting the best position and computing the acceptance fraction.dtype (
Union
[float64
,int64
] (default:<class 'numpy.float64'>
)) – the data type for the values stored in the Trace.
- Return type:
- Returns:
A Result object.