

Prof. Dr. Software SPICE OPUS analog circuit simulator PyOPUS library for circuit simulation and optimization Gridrestrained NelderMead simplex algorithm Python interface to CUTEr test problems for optimization
Tel.: (01) 4768 322 You (dis)like this software? You find it useful? Have some comments?

University of Ljubljana ::
Faculty of Electrical Engineering ::
Árpád Bűrmen :: Software :: Python interface to CUTEr test problems for optimization
Python interface to CUTEr test problems for optimization Note! PyCUTEr is now a part of PyOPUS library for Python. You can find out more about PyOPUS here. About CUTEr is a set of tools for integrating test problems described as SIF files with optimization algorithms for the purpose of testing the algorithm's performance. CUTEr problems are described in a special format (SIF) which is converted to a set of FORTRAN files by using a SIF decoder. These files are then compiled and linked with the CUTEr library and with your program which uses the CUTEr test problem. The CUTEr library provides a plethora of socalled tools  FORTRAN/C functions which evaluate and return various aspects of the test problem (objective function value, constraint values, gradients, constraints Jacobian, and Hessians). There are also CUTEr tools for obtaining information on the test problem and accessing the statistics (number of evaluations) CUTEr keeps internally. The latest versions of the SIF decoder and CUTEr are available at PyCuter is a Python interface to CUTEr along with a set of tools which make it simple to compile, link, and import test problems described by SIF files.
Was it tested? Until now PyCUTEr has only been tested on AMD64 Debian Linux (Squeeze), Python 2.6.6, Numpy 1.4.1 and SciPy 0.7.2. If you have any problems, report them to me. I can help fix things on x86 and AMD64 platform. Drop me a note if you test PyCUTEr on any other platform.
License PyCUTEr (or to be fair the changes to CUTEr) are licensed under LGPLv2.1. It would be nice (although LGPL does not strictly require it) to send your changes back to me so I can publish them in the official implementation of PyCUTEr. You can use PyCUTEr almost any way you want (ain't this LGPL thing just great, huh) as long as you give me proper credit for it.
Installing PyCUTEr Download the SIF decoder (revision 147) and the updated CUTEr package (based on revision 147). You will also need to install Python, NumPy, SciPy, gfortran, and gcc. Also install the Lapack and the Blas libraries. Instead of using the updated CUTEr package you could download CUTEr revision 147 from Older versions of PyCUTEr can be found here. Unpack the SIF decoder, build it by running install_sifdec (answers to first four questions should be: PC, Linux, gfortran, double precision), and set the environmental variables SIFDEC and MYSIFDEC. Add $MYSIFDEC/bin to path so sifdecode will be accessible from anywhere. Also add $SIFDEC/common/man to MANPATH. Unpack CUTEr, build it by running install_cuter (answers to first five questions should be: PC, Linux, gfortran, GNU gcc, double precision), and set the CUTER, and MYCUTER environmental variables. Add $CUTER/common/man to MANPATH. You should also add $CUTER/common/include to C_INCLUDE_PATH, $MYCUTER/double/lib to LIBPATH, and $MYCUTER/bin to PATH. Download SIF files describing the available problems from http://www.cuter.rl.ac.uk/ and create a SIF repository (create a directory, unpack the problems, and set the MASTSIF environmental variable to point to the directory holding the SIF files). Create a directory for the PyCUTEr cache. Set the PYCUTER_CACHE environmental variable to point to the cache directory. Add $PYCUTER_CACHE and $CUTER/common/src/python to the PYTHONPATH envorinmental variable. The last step will make sure you can access the cached problems and the pycutermgr module from Python.
A quick introduction to CUTEr test problems CUTEr provides constrained and unconstrained test problems. The objective function is a map from R^{n} to R: The optimization problem can be subject to simple bounds of the form Beside simple bounds on problem variables some CUTEr problems also provide more sophisticated constraints of the form CUTEr can order the constraints in such manner that equality constraints appear before inequality constraints. It is also possible to place linear constraints before nonlinear constraints. This of course reorders the components of c(x). Similarly variables (components of x) can also be reordered in such manner that nonlinear variables appear before linear ones.
Definitions of the Lagrangian function, the Jacobian matrix, and the Hessian matrix The Lagrangian function is defined as The Jacobian matrix (J) is the matrix of constraint gradients. One row corresponds to one constraint function c_{i}(x). The matrix has n columns. The element in the ith row and jth column is the derivative of the ith constraint function with respect to the jth problem variable The Hessian matrix (H) is the matrix of second derivatives. The element in ith row and jth column corresponds to the second derivative with respect to the ith and jth problem variable. Beside Hessian of the objective CUTEr can also calculate the Hessian of the Lagrangian and the Hessians of the constraint functions. The gradient (of objective, Lagrangian, or constraint functions) is always taken with respect to the problem's variables. Therefore it always has n components.
What PyCUTEr offers All compiled test problems are stored in a cache. The location of the cache can be set by defining the PYCUTER_CACHE environmental variable. If no cache location is defined the current working directory is used for caching the compiled test problems. PyCuter has a manager module named pycutermgr. The manager module (pycutermgr) offers the following functions: Every problem module has several functions that access the corresponding problem's CUTEr tools: All sparse matrices are returned as scipy.sparse.coo_matrix objects.
Examples of PyCUTEr use First you have to import the pycutermgr module import pycutermgr If you want to remove the HS71 problem from the cache, type pycutermgr.clearCache('HS71') To prepare the ROSENBR problem, type pycutermgr.prepareProblem('ROSENBR')This removes the existing ROSENBR entry from the cache before rebuilding the problem interface. The compiled problem is stored as ROSENBR in cache. Importing a prepared problem can be done in two ways. One is to use pycutermgr rb=pycutermgr.importProblem('ROSENBR') while the other is to use Python't import statement import ROSENBR as rb Now you can use the problem. Let's get the information about the imported problem and extract the initial point info=rb.getinfo() x0=info['x'] To evaluate the objective function's value at the extracted initial point, type f=rb.obj(x0) print "f(x0)=", f To get help on all interface functions of the previously imported problem, type help(rb) You can also get help on individual functions of a problem interface help(rb.obj) The pycutermgr module has also builtin help help(pycutermgr) help(pycutermgr.importProblem) For an example of PyCUTEr use with an unconstrained function see $CUTER/common/source/python/udemo.py. A demonstration of usage with a constrained function is in $CUTER/common/source/python/cdemo.py.
Advanced topics Storing compiled problems in cache under arbitrary names pycutermgr.prepareProblem('ROSENBR', destination='rbentry') Importing the compiled problem interface and its removal from the cache must now use rbentry instead of ROSENBR. # Use pycutermgr.importProblem() rb=pycutermgr.importProblem('rbentry') # Use the intrinsic Python import statement import pycuter.rbentry as rb # Remove the compiled problem from cache pycutermgr.clearCache('rbentry') To check if a problem is in cache under the name 'rbentry' without trying to import the actual module, use if pycutermgr.isCached('rbentry'): ... Specifying problem parameters and sifdecode command line options # Prepare the LUBRIFC problem, pass NN=10 to sifdecode pycutermgr.prepareProblem("LUBRIFC", sifParams={'NN': 10}) Arbitrary command line options can be passed to sifdecode by specifying them in form of a list of strings and passing the list to pycutermgr.prepareProblem() as sifOptions. The following is the equivalent of the last example # Prepare the LUBRIFC problem, pass NN=10 to sifdecode pycutermgr.prepareProblem("LUBRIFC", sifOptions=['param', 'NN=10']) Specifying variable and constraint ordering pycutermgr.prepareProblem("SOMEPROBLEM", nvfirst=True)If nvfirst is not specified it defaults to False. In that case no particular variable ordering is imposed. The variable ordering will be reflected in the order of variable names returned by the varnames() problem interface function. To put equality constraints before inequality constraints set the efirst parameter to True. pycutermgr.prepareProblem("SOMEPROBLEM", efirst=True)Similarly linear constraints can be placed before nonlinear ones by setting lfirst to True. pycutermgr.prepareProblem("SOMEPROBLEM", lfirst=True)Parameters efirst and lfirst default to False meaning that no particular constraint ordering is imposed. The constraint ordering will be reflected in the order of constraint names returned by the connames() problem interface function. If both efirst and lfirst are set to True, the ordering is a follows: linear equality constraints followed by linear inequations, nonlinear equations, and finally nonlinear inequations. Problem information Additional entries are available if the problem han constraints (m>0): The names of variables and constraints are returned by the varnames() and connames() problem interface functions. Usage statistics For constrained problems the following additional members are available Problem preparation and internal cache organization $PYCUTER_CACHE/pycuter has a dummy __init__.py file generated by pycutermgr.prepareProblem() which specifies that $PYCUTER_CACHE/pycuter is a Python module. Every problem has its own subdirectory in $PYCUTER_CACHE/pycuter. In that subdirectory problem decoding (with sifdecode) and compilation (with gfortran and Python distutils) take place. pycutermgr.prepareProblem() also generates an __init__.py file for every problem which takes care of initialization when the problem interface is imported. The actual binary interaface is in _pycuteritf.so. The __init__.py script requires the presence of the OUTSDIF.d file where the problem description is stored. Everything else is neded at compile time only. Some functions in the _pycuteritf.so module are private (their name starts with an underscore. These functions are called by wrappers defined in problem's __init__.py. An example for this are the sparse CUTEr tools like scons(). scons() is actually a wrapper defined in __init__.py. It calls the _scons() function from the problem's _pycuteritf.so binary interface module and converts its return values to a scipy.sparse.coo_matrix object. scons() returns the scipy.sparse.coo_matrix object for J instead of a NumPy array object. The problem's _pycuteritf binary module is also accessible. If the interface module is imported as rb then the _scons() interface function can be accessed as rb._pycuteritf._scons.
Changes to the original CUTEr Revision 152 No additional changes with respect to PyCUTEr based on revision 147. Revision 147 No additional changes with respect to PyCUTEr based on revision 116. Revision 116 $CUTER/config/all.cf cuter2/config/linux.cf cuter2/common/src/tools/pycuteritf.c cuter2/common/src/python/pycutermgr.py cuter2/common/src/python/udemo.py cuter2/common/src/python/cdemo.py
Bugs fixed 20130918  fixed a bug caused by Ubuntu's gcc flag noasneeded (the built problems could not be loaded into Python). Pointed out by Jae Hwa Lee, fixed by Felix Lenders. 20130514  Added isCached() to pycutermgr.py. Closed memory leaks when tuples or dictionaries are returned. 20110901  fixed a minor bug that caused PyCuter to attempt to create __init__.py in $PYCUTER_CACHE/pycuter before $PYCUTER_CACHE/pycuter was even created. Thanks to Jae Hwa Lee.
Last update: Sep 22 2017


(C)2018 Árpád Bűrmen. All rights reserved. 