Skip to content
GitLab
Menu
Projects
Groups
Snippets
Loading...
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in / Register
Toggle navigation
Menu
Open sidebar
Sielskyi Yevhenii
sho
Commits
66c7ae93
Commit
66c7ae93
authored
Dec 14, 2019
by
nojhan
Browse files
add a readme file
parent
ce190c56
Changes
1
Hide whitespace changes
Inline
Side-by-side
README.md
0 → 100644
View file @
66c7ae93
SHO — Stochastic Heuristics Optimization
########################################
SHO is a didactic Python framework for implementing metaheuristics
(or evolutionary computation, or search heuristics).
Its main objective is to free students from implementing boring stuff
and allow them to concentrate on single operator implementation.
The framework implements a simple sensor placement problem
and handle metaheuristics manipulating solutions represented as
numerical vectors or bitstrings.
Executable
==========
The main interface is implemented in
`snp.py`
.
New algorithms should be integrated within this file and the interface should not be modified.
One may add arguments, but not remove or change the contracts of the existing ones.
The file
`snp_landscape.py`
is an example that plots the objective function
and a greedy search trajectory for a simple problem with only two dimensions.
Architecture
============
The design pattern of the framework is a functional approach to composition.
The goal is to be able to assemble a metaheuristic, by plugging atomic
functions in an algorithm template.
Operators
---------
The base of the pattern is a function that contains the main loop
of the algorithm, and call other functions called "operators".
Example of those algorithms are in the
`algo`
module.
For instance, the
`random`
algorithm depends on an objective function
`func`
,
an initialization operator
`init`
and a stopping criterion operator
`again`
.
Encoding
--------
Some operator do not depend on the way solutions are encoded
(like the stopping criterions) and some operators do depend on the encoding.
The former are defined in their own modules while the later are defined
in the module corresponding to their encoding (either
`num`
or
`bit`
).
Interface capture
-----------------
As they are assembled in an algorithm that do not know their internal
in advance, an operators needs to honor an interface.
For instance, the
`init`
operator's interface takes no input parameter
and returns a solution to the problem.
However, some operator may need additional parameters to be passed.
To solve this problem, the framework use an interface capture pattern,
implemented in the
`make`
module.
Basically, a function in this module capture the operator function's full
interface and returns a function having the expected interface of the
operator.
The implicit rule is to use positional arguments for mandatory parameters
on which the operator is defined, and keyword arguments for parameters
which are specific to the operator.
Exercises
=========
Setup
-----
To setup your own solver, first copy the
`snp.py`
file and rename it
with your name, for instance
`dreo.py`
.
You will then add your algorithm(s) into this executable.
Two example algorithms are provided: a
`random`
search
and a
`greedy`
search.
Several useful stopping criterions are provided.
The corresponding encoding-dependent operators are also provided,
for both numeric and bitstring encodings.
The
`snp.py`
file shows how to assemble either a numeric greedy solver
or a bitstring greedy solver.
Implement a simulated annealing
-------------------------------
Implement an evolutionary algorithm
-----------------------------------
Implement an expected run time empirical cumulative density function
------------------------------------------------------------------
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
.
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment