ssmgo  SSm GO toolbox 




SSm GO - a toolbox for global optimization in Matlab using scatter search

Below you will find links to the documentation of SSm GO latest release (R2010A).

Installation notes

-- SSmGO Toolbox R2010A --

Requirements:

- Matlab 6.5 or higher, 32 bits (tested with 6.5 to 7.8 under Windows)
- Matlab Optimization Toolbox (for using some of the local solvers, like e.g., fmincon or fminsearch)

Note: the current full version is for Windows only. Some features may work under Linux, but several of the local solvers will not.

Installation:

0- Download from http://www.iim.csic.es/~gingproc/ssmGOdownload.html
1- Unzip the .zip (or .rar) archive in your PC (do not change the dir structure) using the password you obtained from us
2- Start a Matlab session
3- Type "which ssm_kernel". If you get a non-empty string, you may need to remove an older version of the SSmGO Toolbox from the Matlab path
5- Go to the root folder in which you unzipped the toolbox
5- Type "ssm_startup"
6- Start using SSmGO Toolbox (see tutorial to know how to implement optimization problems)

Questions/bug reports:

Send email to gingproc@iim.csic.es

User's guide

pdf
Click here to download:
SSm-eSS_userguide.pdf (164 KB)

Introduction to the methods implemented in the SSm GO toolbox

pdf
Click here to download:
SSm_intro.pdf (870 KB)

QUICK HELP

The SSm GO currentlly offers two solvers, SSm and eSS.

Below you will find a quick guide to each of them. More detailed documentation is available at the documentation links above.

 
----------------------------------------------------------------------------------------------------------------------------------------------------------------------

eSS solver

function [Results]=ess_kernel(problem,opts,varargin)
Function   : eSS Release 2010A
Written by : Process Engineering Group IIM-CSIC
Created on : 12/03/2008
Last Update: 11/10/2010
Email      : gingproc@iim.csic.es

(c) CSIC, Spanish Council for Scientific Research

Global optimization algorithm for MINLP's based on Scatter Search

  eSS attempts to solve problems of the form:
      min F(x)  subject to:  ceq(x) = 0 (equality constraints)
       x                     c_L <= c(x) <= c_U (inequality constraints)
                             x_L <= x <= x_U (bounds on the decision variables)

Constraint functions, if applicable, must be declared in the same script as the
objective function as a second output argument:
e.g., [f,c]=myfunction(x)
      f=objective function value
      g=vector containing the constraints
      return

Please have a look at the manual before using eSS

      USAGE: Results=ess_kernel(problem,opts,p1,p2,....,pn);

INPUT PARAMETERS:
****************
  problem - Structure containing problem settings
      problem.f   = Name of the file containing the objective
                    function (String)
      problem.x_L = Lower bounds of decision variables (vector)
      problem.x_U = Upper bounds of decision variables (vector)
      problem.x_0 = Initial point(s) (optional; vector or matrix)

      Additionally, fill the following fields if your problem has
      non-linear constraints
      problem.neq     = Number of equality constraints (Integer; do not define it
                        if there are no equality constraints)
      problem.c_L     = Lower bounds of nonlinear inequality constraints
                       (vector)
      problem.c_U     = Upper bounds of nonlinear inequality constraints
                        (vector)
      problem.int_var = Number of integer variables (Integer)
      problem.bin_var = Number of binary variables  (Integer)
      problem.vtr     = Objective function value to be reached (optional)

NOTE: The order of decision variables is x=[cont int bin]

  opts - Structure containing options (if set as opts=[] defaults options
         will be loaded) Type "ssm_kernel" or "ssm_kernel('defaults')" to
         get the default options

      User options
          opts.maxeval    = Maximum number of function evaluations
                            (Default 1000)
          opts.maxtime    = Maximum CPU time in seconds (Default 60)
          opts.iterprint  = Print each iteration on screen: 0-Deactivated
                            1-Activated (Default 1)
          opts.plot       = Plots convergence curves: 0-Deactivated,
                            1-Plot curves on line, 2-Plot final results
                            (Default 0)
          opts.weight     = Weight that multiplies the penalty term added
                            to the objective function in constrained
                            problems (Default 1e6)
          opts.log_var    = Indexes of the variables which will be used
                            to generate diverse solutions in different
                            orders of magnitude (vector)
          opts.tolc       = Maximum absolute violation of the constraints
                            (Default 1e-5)
          opts.prob_bound = Probability (0-1) of biasing the search towards
                            the bounds (Default 0.5)
          opts.inter_save = Saves results in a mat file in intermediate
                            iterations. Useful for very long runs
                            (Binary; Default = 0)

      Global options
          opts.dim_refset         = Number of elements in Refset
                                    (Integer; automatically calculated)
          opts.ndiverse           = Number of solutions generated by the
                                    diversificator (Default 10*nvar)
          opts.combination        = Type of combination of Refset
                                    elements (Default 1)
                                    1: hyper-rectangles
                                    2: linear combinations

      Local options
          opts.local.solver               = Choose local solver
                                            0: Local search deactivated
                                            'fmincon'(Default),
                                            'fminsearch', 'solnp'
                                            'n2fb','dn2fb','dhc','hooke'
                                            'ipopt','misqp','lsqnonlin'
          opts.local.tol                  = Level of tolerance in local
                                            search
          opts.local.iterprint            = Print each iteration of local
                                            solver on screen (Binary;
                                            default = 0)
          opts.local.n1                   = Number of iterations
                                            before applying
                                            local search for the 1st time
                                            (Default 1)
          opts.local.n2                   = Minimum number of iterations
                                            in the global
                                            phase between 2 local calls
                                            (Default 10)
          opts.local.balance              = Balances between quality (=0)
                                            and diversity (=1) for
                                            choosing initial points for
                                            the local search (default
                                            0.5)
          opts.local.finish               = Applies local search to the
                                            best solution found once the
                                            optimization if finished
                                            (same values as
                                            opts.local.solver)
          opts.local.bestx                = When activated (i.e. =1) only
                                            applies local search to the
                                            best solution found to
                                            date,ignoring filters
                                            (Default=0)


  p1,p2... :  optional input parameters to be passed to the objective
  function


OUTPUT PARAMETERS:
*****************
A file called "ssm_report.mat" is generated containing.

  problem - Structure containing problem settings
  opts    - Structure containing all options
  Results - Structure containing results

Fields in Results
      Results.fbest                   = Best objective function value
                                        found after the optimization
      Results.xbest                   = Vector providing the best
                                        function value
      Results.cpu_time                = Time in seconds consumed in the
                                        optimization
      Results.f                       = Vector containing the best
                                        objective function value after each
                                        iteration
      Results.x                       = Matrix containing the best vector
                                        after each iteration
      Results.time                    = Vector containing the cpu time
                                        consumed after each iteration
      Results.neval                   = Vector containing the number of
                                        function evaluations after each
                                        iteration
      Results.numeval                 = Number of function evaluations
      Results.local_solutions         = Local solutions found by the
                                        local solver (in rows)
      Results.local_solutions_values  = Function values of the local
                                        solutions
      Results.end_crit                = Criterion to finish the
                                        optimization
                                        1: Maximal number of function
                                        evaluations achieved
                                        2: Maximum allowed CPU Time
                                        achieved
                                        3: Value to reach achieved

             NOTE: To plot convergence curves type:
             stairs(Results.time,Results.f) or stairs(Results.neval,Results.f)
REFERENCES

If you use eSS and publish the results, please cite the following papers:

Egea, J.A., Balsa-Canto, E., García, M.S.G., Banga, J.R. (2009) Dynamic
optimization of nonlinear processes with an enhanced scatter search
method. Industrial & Engineering Chemistry Research 49(9): 4388-4401.

Egea, J.A., Martí, R., Banga, J.R. (2010) An evolutionary method for
complex-process optimization. Computers & Operations Research 37(2):
315-324.

----------------------------------------------------------------------------------------------------------------------------------------------------------------------

SSm solver

function [Results]=ssm_kernel(problem,opts,varargin)
Function   : SSm Toolbox R2010A
Written by : Process Engineering Group IIM-CSIC (jegea@iim.csic.es)
Created on : 15/06/2005
Last Update: 11/10/2010
Email      : gingproc@iim.csic.es

(c) CSIC, Spanish Council for Scientific Research

Global optimization algorithm for MINLP's based on Scatter Search

  SSm attempts to solve problems of the form:
      min F(x)  subject to:  ceq(x) = 0 (equality constraints)
       x                     c_L <= c(x) <= c_U (inequality constraints)
                             x_L <= x <= x_U (bounds on the decision variables)

Constraint functions, if applicable, must be declared in the same script as the
objective function as a second output argument:
e.g., [f,c]=myfunction(x)
      f=objective function value
      g=vector containing the constraints
      return

Please have a look at the manual before using SSm

      USAGE: Results=ssm_kernel(problem,opts,p1,p2,....,pn);

INPUT PARAMETERS:
****************
  problem - Structure containing problem settings
      problem.f   = Name of the file containing the objective
                    function (string)
      problem.x_L = Lower bounds of decision variables (vector)
      problem.x_U = Upper bounds of decision variables (vector)
      problem.x_0 = Initial point (vector, optional)

      Additionally, fill the following fields if your problem has
      non-linear constraints
      problem.neq     = Number of equality constraints (integer; do not define it
                        if there are no equality constraints)
      problem.c_L     = Lower bounds of nonlinear inequality constraints
                        (vector)
      problem.c_U     = Upper bounds of nonlinear inequality constraints
                        (vector)
      problem.int_var = Number of integer variables (integer)
      problem.bin_var = Number of binary variables  (integer)
      problem.vtr     = Objective function value to be reached (optional)

NOTE: The order of decision variables is x=[cont int bin]

  opts - Structure containing options (if set as opts=[] defaults options
         will be loaded) Type "ssm_kernel" or "ssm_kernel('defaults')" to
         get the default options

      User options
          opts.maxeval    = Maximum number of function evaluations
                            (Default 1000)
          opts.maxtime    = Maximum CPU time in seconds (Default 60)
          opts.iterprint  = Print each iteration on screen: 0-Deactivated
                            1-Activated (Default 1)
          opts.plot       = Plots convergence curves: 0-Deactivated,
                            1-Plot curves on line, 2-Plot final results
                            (Default 0)
          opts.weight     = Weight that multiplies the penalty term added
                            to the objective function in constrained
                            problems (Default 1e6)
          opts.log_var    = Indexes of the variables which will be used
                            to generate diverse solutions in different
                            orders of magnitude (vector)
          opts.tolc       = Maximum absolute violation of the constraints
                            (Default 1e-5)
          opts.prob_bound = Probability (0-1) of biasing the search towards
                            the bounds (Default 0.5)
          opts.inter_save = Saves results in a mat file in intermediate
                            iterations. Useful for very long runs
                            (Binary; Default = 0)

      Global options
          opts.dim_refset         = Number of elements in Refset
                                    (automatically calculated)
          opts.ndiverse           = Number of solutions generated by the
                                    diversificator (Default 10*nvar)
          opts.initiate           = Type of Refset initialization
                                    (Binary; Default = 1)
                                    0: Take bounds, middle point and fill
                                    by euclidean distance
                                    1: Evaluate all the diverse
                                    solutions,take the dim_refset/2 best
                                    solutions and fill by euclidean
                                    distance
          opts.combination        = Type of combination of Refset
                                    elements (Default 1)
                                    1: hyper-rectangles
                                    2: linear combinations
          opts.regenerate         = Type of Refset regeneration (Default
                                    3)
                                    1: Regeneration by distance diversity
                                    2: Regeneration by direction
                                    diversity
                                    3: Randomly alternates 1 and 2
          opts.delete             = Maximum number of Refset elements
                                    deleted when regenerating Refset
                                    (Default 'standard')
                                    'standard': Maximum deleted elements=
                                    dim_refset/2 (half of the elements)
                                    'aggressive': Delete dim_refset-1
                                    (all of them except the best solution
                                    found)
          opts.intens             = Iteration interval between
                                    intensifications (default 10)
          opts.tolf               = Function tolerance for joining the
                                    Refset (default 1e-4)
          opts.diverse_criteria   = Criterion for diversification in the
                                    Refset (Default 1)
                                    1: euclidean distance
                                    2: tolerances
          opts.tolx               = Variable tolerance for joining the
                                    Refset when the euclidean distance is
                                    deactivated(default 1e-3 for all
                                    variables)
      Local options
          opts.local.solver               = Choose local solver
                                            0: Local search deactivated
                                            'fmincon'(Default),
                                            'fminsearch','solnp'
                                            'n2fb','dn2fb','dhc','hooke'
                                            'ipopt','misqp','lsqnonlin'
          opts.local.tol                  = Level of tolerance in local
                                            search (1-Relaxed, 2-Medium
                                            (default), 3-tight)
          opts.local.iterprint            = Print each iteration of local
                                            solver on screen (Binary;
                                            Default = 0).
          opts.local.n1                   = Number of function
                                            evaluations before applying
                                            local search for the 1st time
                                            (Default 100*nvar)
          opts.local.n2                   = Minimum number of function
                                            evaluations in the global
                                            phase between 2 local calls
                                            (Default 200*nvar)
          opts.local.finish               = Applies local search to the
                                            best solution found once the
                                            optimization if finished
                                            (same values as
                                            opts.local.solver)
          opts.local.bestx                = When activated (i.e. =1) only
                                            applies local search to the
                                            best solution found to
                                            date,ignoring filters
                                            (Default=0)
          opts.local.merit_filter         = Activation of merit filter
                                            for local search (Default 1)
                                            0: Filter deactivated
                                            1: Filter activated
          opts.local.distance_filter      = Activation of distance filter
                                            for local search (Default 1)
                                            0: Filter deactivated
                                            1: Filter activated
          opts.local.thfactor             = Merit filter relaxation
                                            parameter (Default 0.2)
          opts.local.maxdistfactor        = Distance filter relaxation
                                            parameter (Default 0.2)
          opts.local.wait_maxdist_limit   = Apply distance filter
                                            relaxation after this number
                                            of function evaluations
                                            without success in passing
                                            filter (Default 20)
          opts.local.wait_th_limit        = Apply merit filter relaxation
                                            after this number of function
                                            evaluations without success in
                                            passing filter (Default 20)
      General option:
          opts.strategy                   =  If >0 ignores user's
                                             declared options and uses
                                             these strategies
                                            1: Fast
                                            2: Average (forces SSm to use
                                               only default options)
                                            3: Robust


  p1,p2... :  optional input parameters to be passed to the objective
  function


OUTPUT PARAMETERS:
*****************
A file called "ssm_report.mat" is generated containing.

  problem - Structure containing problem settings
  opts    - Structure containing all options
  Results - Structure containing results

Fields in Results
      Results.fbest                   = Best objective function value
                                        found after the optimization
      Results.xbest                   = Vector providing the best
                                        function value
      Results.cpu_time                = Time in seconds consumed in the
                                        optimization
      Results.f                       = Vector containing the best
                                        objective function value after each
                                        iteration
      Results.x                       = Matrix containing the best vector
                                        after each iteration
      Results.time                    = Vector containing the cpu time
                                        consumed after each iteration
      Results.neval                   = Vector containing the number of
                                        function evaluations after each
                                        iteration
      Results.numeval                 = Number of function evaluations
      Results.local_solutions         = Local solutions found by the
                                        local solver (in rows)
      Results.local_solutions_values  = Function values of the local
                                        solutions
      Results.end_crit                = Criterion to finish the
                                        optimization
                                        1: Maximal number of function
                                        evaluations achieved
                                        2: Maximum allowed CPU Time
                                        achieved
                                        3: Value to reach achieved

             NOTE: To plot convergence curves type:
             stairs(Results.time,Results.f) or stairs(Results.neval,Results.f)

References

Original SSm solver:

Rodriguez-Fernandez, M., J. A. Egea and J. R. Banga (2006) Novel Metaheuristic for Parameter Estimation in Nonlinear Dynamic Biological Systems. BMC Bioinformatics 7:483.
(Downloadable at http://www.biomedcentral.com/content/pdf/1471-2105-7-483.pdf)

Egea, J.A., M. Rodriguez-Fernandez, J. R. Banga and R. Martí (2007) Scatter Search for chemical and bioprocess optimization. Journal of Global Optimization 37(3):481-503.

eSS solver (latest version, recommended):

Egea, J.A., Balsa-Canto, E., García, M.G., & Banga, J.R. (2009). Dynamic optimization of nonlinear processes with an enhanced scatter search method.  Industrial and Engineering Chemistry Research 48(9):4388-4401.

Egea, J.A., Martí, R., & Banga, J.R. (2010). An evolutionary method for complex-process optimization.   Computers and Operations Research 37(2):315-324.

Rodriguez-Fernandez, M., J. A. Egea and J. R. Banga (2006) Novel Metaheuristic for Parameter Estimation in Nonlinear Dynamic Biological Systems. BMC Bioinformatics 7:483.(PDF) (abstract)










I am soooo fake pre-loading this image so the navigation doesn't skip while loading the over state. I know I could use the sliding doors technique to avoid this fate, but I am too lazy.