Optunity-0.2.0/0000755000175000017500000000000012364000746013200 5ustar badnbadn00000000000000Optunity-0.2.0/optunity/0000755000175000017500000000000012364000746015073 5ustar badnbadn00000000000000Optunity-0.2.0/optunity/functions.py0000644000175000017500000002424212363506766017475 0ustar badnbadn00000000000000#! /usr/bin/env python # Copyright (c) 2014 KU Leuven, ESAT-STADIUS # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions # are met: # # 1. Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # # 2. Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # # 3. Neither name of copyright holders nor the names of its contributors # may be used to endorse or promote products derived from this software # without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR # PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF # LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """A variety of useful function decorators for logging, constraints and more. Main features in this module: * :func:`constrained` * :func:`logged` * :func:`max_evals` * :func:`dict2call_log` * :func:`call_log2dict` .. moduleauthor:: Marc Claesen """ import itertools import collections import functools import threading def constr_ub_o(field, bounds, *args, **kwargs): """Models ``args.field < bounds``.""" return kwargs[field] < bounds def constr_ub_c(field, bounds, *args, **kwargs): """Models ``args.field <= bounds``.""" return kwargs[field] <= bounds def constr_lb_o(field, bounds, *args, **kwargs): """Models ``args.field > bounds``.""" return kwargs[field] > bounds def constr_lb_c(field, bounds, *args, **kwargs): """Models ``args.field >= bounds``.""" return kwargs[field] >= bounds def constr_range_oo(field, bounds, *args, **kwargs): """Models ``args.field in (bounds[0], bounds[1])``.""" return kwargs[field] > bounds[0] and kwargs[field] < bounds[1] def constr_range_cc(field, bounds, *args, **kwargs): """Models ``args.field in [bounds[0], bounds[1]]``.""" return kwargs[field] >= bounds[0] and kwargs[field] <= bounds[1] def constr_range_oc(field, bounds, *args, **kwargs): """Models ``args.field in (bounds[0], bounds[1]]``.""" return kwargs[field] > bounds[0] and kwargs[field] <= bounds[1] def constr_range_co(field, bounds, **kwargs): """Models ``args.field in [bounds[0], bounds[1])``.""" return kwargs[field] >= bounds[0] and kwargs[field] < bounds[1] class ConstraintViolation(Exception): """Thrown when constraints are not met.""" def __init__(self, constraint, *args, **kwargs): self.__constraint = constraint self.__args = args self.__kwargs = kwargs @property def args(self): return self.__args @property def constraint(self): return self.__constraint @property def kwargs(self): return self.__kwargs def constrained(constraints): """Decorator that puts constraints on the domain of f. >>> @constrained([lambda x: x > 0]) ... def f(x): return x+1 >>> f(1) 2 >>> f(0) Traceback (most recent call last): ... ConstraintViolation >>> len(f.constraints) 1 """ def wrapper(f): @functools.wraps(f) def wrapped_f(*args, **kwargs): violations = [c for c in wrapped_f.constraints if not c(*args, **kwargs)] if violations: raise ConstraintViolation(violations, *args, **kwargs) return f(*args, **kwargs) wrapped_f.constraints = constraints return wrapped_f return wrapper def violations_defaulted(default): """Decorator to default function value when a :class:`ConstraintViolation` occurs. >>> @violations_defaulted("foobar") ... @constrained([lambda x: x > 0]) ... def f(x): return x+1 >>> f(1) 2 >>> f(0) 'foobar' """ def wrapper(f): @functools.wraps(f) def wrapped_f(*args, **kwargs): try: return f(*args, **kwargs) except ConstraintViolation: return default return wrapped_f return wrapper def logged(f): """Decorator that logs unique calls to ``f``. The call log can always be retrieved using ``f.call_log``. Decorating a function that is already being logged has no effect. The call log is an ``OrderedDict`` with a ``namedtuple`` as key. The namedtuple has fields based on ``*args`` and ``**kwargs``, for ``*args`` the tuple has fields ``pos_``. >>> @logged ... def f(x): return x+1 >>> a, b, c = f(1), f(1), f(2) >>> f.call_log OrderedDict([(args(pos_0=1), 2), (args(pos_0=2), 3)]) logged as inner decorator: >>> @logged ... @constrained([lambda x: x > 1]) ... def f2(x): return x+1 >>> f2.call_log OrderedDict() >>> f2(2) 3 >>> f2.call_log OrderedDict([(args(pos_0=2), 3)]) logged as outer decorator: >>> @constrained([lambda x: x > 1]) ... @logged ... def f3(x): return x+1 >>> f3.call_log OrderedDict() >>> f3(2) 3 >>> f3.call_log OrderedDict([(args(pos_0=2), 3)]) logging twice does not remove original call_log >>> @logged ... def f(x): return 1 >>> f(1) 1 >>> f.call_log OrderedDict([(args(pos_0=1), 1)]) >>> @logged ... @functools.wraps(f) ... def f2(x): return f(x) >>> f2.call_log OrderedDict([(args(pos_0=1), 1)]) """ if hasattr(f, 'call_log'): return f lock = threading.Lock() @functools.wraps(f) def wrapped_f(*args, **kwargs): d = kwargs.copy() d.update(dict([('pos_' + str(i), item) for i, item in enumerate(args)])) if not wrapped_f.argtuple: f.argtuple = collections.namedtuple('args', d.keys()) t = f.argtuple(**d) with lock: value = wrapped_f.call_log.get(t, False) if value is False: value = f(*args, **kwargs) with lock: wrapped_f.call_log[t] = value return value wrapped_f.call_log = collections.OrderedDict() wrapped_f.argtuple = None return wrapped_f def dict2call_log(calldict): """Converts given dict to a valid call log used by logged functions. Given dictionary must have the following structure: ``{'args': {'argname': []}, 'values': []}`` >>> dict2call_log({'args': {'x': [1, 2]}, 'values': [2, 3]}) OrderedDict([(Pars(x=1), 2), (Pars(x=2), 3)]) """ Pars = collections.namedtuple('Pars', calldict['args'].keys()) return collections.OrderedDict((Pars(*args), val) for args, val in zip(zip(*calldict['args'].values()), calldict['values'])) def call_log2dict(call_log): """Returns given call_log into a dictionary. The call_log is an ``OrderedDict((namedtuple, value))``. The result is a dict with the following structure: ``{'args': {'argname': []}, 'values': []}`` >>> Pars = collections.namedtuple('Pars',['x','y']) >>> call_log = collections.OrderedDict({Pars(1,2): 3}) >>> call_log2dict(call_log) {'args': {'y': [2], 'x': [1]}, 'values': [3]} """ if call_log: args = dict([(k, [getattr(arg, k) for arg in call_log.keys()]) for k in list(call_log.keys())[0]._fields]) # note: wrap keys() in list to bypass view in Python 3 return {'args': args, 'values': list(call_log.values())} # again: wrap in list() or JSON serializing fails in Python 3 else: return {'args': {}, 'values': []} def negated(f): """Decorator to negate f such that f'(x) = -f(x).""" @functools.wraps(f) def wrapped_f(*args, **kwargs): return -f(*args, **kwargs) return wrapped_f class MaximumEvaluationsException(Exception): """Raised when the maximum number of function evaluations are used.""" def __init__(self, max_evals): self._max_evals = max_evals @property def max_evals(self): """Returns the maximum number of evaluations that was permitted.""" return self._max_evals def max_evals(max_evals): """Decorator to enforce a maximum number of function evaluations. Throws a MaximumEvaluationsException during evaluations after the maximum is reached. Adds a field ``f.num_evals`` which tracks the number of evaluations that have been performed. >>> @max_evals(1) ... def f(x): return 2 >>> f(2) 2 >>> f(1) Traceback (most recent call last): ... MaximumEvaluationsException >>> try: ... f(1) ... except MaximumEvaluationsException as e: ... e.max_evals 1 """ def wrapper(f): @functools.wraps(f) def wrapped_f(*args, **kwargs): if wrapped_f.num_evals >= max_evals: raise MaximumEvaluationsException(max_evals) else: wrapped_f.num_evals += 1 return f(*args, **kwargs) wrapped_f.num_evals = 0 return wrapped_f return wrapper def static_key_order(keys): """Decorator to fix the key order for use in function evaluations. A fixed key order allows the function to be evaluated with a list of unnamed arguments rather than kwargs. >>> @static_key_order(['foo', 'bar']) ... def f(bar, foo): return bar + 2 * foo >>> f([3,5]) 11 """ def wrapper(f): @functools.wraps(f) def wrapped_f(*args): return f(**dict([(k, v) for k, v in zip(keys, args)])) return wrapped_f return wrapper if __name__ == '__main__': pass Optunity-0.2.0/optunity/api.py0000644000175000017500000002652512364000702016220 0ustar badnbadn00000000000000#! /usr/bin/env python # Copyright (c) 2014 KU Leuven, ESAT-STADIUS # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions # are met: # # 1. Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # # 2. Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # # 3. Neither name of copyright holders nor the names of its contributors # may be used to endorse or promote products derived from this software # without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR # PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF # LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """A collection of top-level API functions for Optunity. Main functions in this module: * :func:`make_solver` * :func:`suggest_solver` * :func:`manual` * :func:`maximize` * :func:`minimize` * :func:`optimize` We recommend using these functions rather than equivalents found in other places, e.g. :mod:`optunity.solvers`. .. moduleauthor:: Marc Claesen """ import functools import timeit import sys import operator # optunity imports from . import functions as fun from . import solvers from . import solver_registry from . import parallel as par from .util import DocumentedNamedTuple as DocTup def _manual_lines(solver_name=None): """Brief solver manual. :param solver_name: (optional) name of the solver to request a manual from. If none is specified, a general manual and list of all registered solvers is returned. :result: * list of strings that contain the requested manual * solver name(s): name of the solver that was specified or list of all registered solvers. Raises ``KeyError`` if ``solver_name`` is not registered.""" if solver_name: return solver_registry.get(solver_name).desc_full, [solver_name] else: return solver_registry.manual(), solver_registry.solver_names() def manual(solver_name=None): """Prints the manual of requested solver. :param solver_name: (optional) name of the solver to request a manual from. If none is specified, a general manual is printed. Raises ``KeyError`` if ``solver_name`` is not registered.""" if solver_name: man = solver_registry.get(solver_name).desc_full else: man = solver_registry._manual_lines() print('\n'.join(man)) optimize_results = DocTup(""" **Result details includes the following**: optimum optimal function value f(solution) stats statistics about the solving process call_log the call log report solver report, can be None """, 'optimize_results', ['optimum', 'stats', 'call_log', 'report'] ) optimize_stats = DocTup(""" **Statistics gathered while solving a problem**: num_evals number of function evaluations time wall clock time needed to solve """, 'optimize_stats', ['num_evals', 'time']) def suggest_solver(num_evals=50, solver_name=None, **kwargs): if solver_name: solvercls = solver_registry.get(solver_name) else: solver_name = 'particle swarm' solvercls = solvers.ParticleSwarm if hasattr(solvercls, 'suggest_from_box'): suggestion = solvercls.suggest_from_box(num_evals, **kwargs) elif hasattr(solvercls, 'suggest_from_seed'): # the seed will be the center of the box that is provided to us seed = dict([(k, float(v[0] + v[1]) / 2) for k, v in kwargs.items()]) suggestion = solvercls.suggest_from_seed(num_evals, **seed) else: raise ValueError('Unable to instantiate ' + solvercls.name + '.') suggestion['solver_name'] = solver_name return suggestion def maximize(f, num_evals=50, solver_name=None, **kwargs): """Basic function maximization routine. Maximizes ``f`` within the given box constraints. :param f: the function to be maximized :param num_evals: number of permitted function evaluations :param solver_name: name of the solver to use (optional) :param kwargs: box constraints, a dict of the following form ``{'parameter_name': [lower_bound, upper_bound], ...}`` :returns: retrieved maximum, extra information and solver info This function will implicitly choose an appropriate solver and its initialization based on ``num_evals`` and the box constraints. """ # sanity check on box constraints assert all([len(v) == 2 and v[0] < v[1] for v in kwargs.values()]), 'Box constraints improperly specified: should be [lb, ub] pairs' func = _wrap_hard_box_constraints(f, kwargs, sys.float_info.min) suggestion = suggest_solver(num_evals, solver_name, **kwargs) solver = make_solver(**suggestion) solution, details = optimize(solver, func, maximize=True, max_evals=num_evals) return solution, details, suggestion def minimize(f, num_evals=50, solver_name=None, **kwargs): """Basic function minimization routine. Minimizes ``f`` within the given box constraints. :param f: the function to be minimized :param num_evals: number of permitted function evaluations :param solver_name: name of the solver to use (optional) :param kwargs: box constraints, a dict of the following form ``{'parameter_name': [lower_bound, upper_bound], ...}`` :returns: retrieved minimum, extra information and solver info This function will implicitly choose an appropriate solver and its initialization based on ``num_evals`` and the box constraints. """ # sanity check on box constraints assert all([len(v) == 2 and v[0] < v[1] for v in kwargs.values()]), 'Box constraints improperly specified: should be [lb, ub] pairs' func = _wrap_hard_box_constraints(f, kwargs, sys.float_info.max) suggestion = suggest_solver(num_evals, solver_name, **kwargs) solver = make_solver(**suggestion) solution, details = optimize(solver, func, maximize=False, max_evals=num_evals) return solution, details, suggestion def optimize(solver, func, maximize=True, max_evals=0, pmap=map): """Optimizes func with given solver. Returns the solution and a namedtuple with further details. Please refer to docs of optunity.maximize_results and optunity.maximize_stats. Raises KeyError if - ``solver_name`` is not registered - ``solver_config`` is invalid to instantiate ``solver_name`` """ ## FIXME: negating function values is fragile, since the function # may already be logged by the user, in which case the log will # be polluted with negated function values if max_evals > 0: f = fun.max_evals(max_evals)(func) else: f = func f = fun.logged(f) num_evals = -len(f.call_log) time = timeit.default_timer() try: solution, report = solver.optimize(f, maximize, pmap=pmap) except fun.MaximumEvaluationsException: # early stopping because maximum number of evaluations is reached # retrieve solution from the call log report = None if maximize: index, _ = max(enumerate(f.call_log.values()), key=operator.itemgetter(1)) else: index, _ = min(enumerate(f.call_log.values()), key=operator.itemgetter(1)) solution = operator.itemgetter(index)(f.call_log.keys())._asdict() time = timeit.default_timer() - time optimum = f(**solution) num_evals += len(f.call_log) # use namedtuple to enforce uniformity in case of changes stats = optimize_stats(num_evals, time) call_dict = fun.call_log2dict(f.call_log) return solution, optimize_results(optimum, stats._asdict(), call_dict, report) optimize.__doc__ = ''' Optimizes func with given solver. Returns the solution and a ``namedtuple`` with further details. ''' + optimize_results.__doc__ + optimize_stats.__doc__ def make_solver(solver_name, *args, **kwargs): """Creates a Solver from given parameters. Raises ``KeyError`` if - ``solver_name`` is not registered - ``*args`` and ``**kwargs`` are invalid to instantiate the solver. """ solvercls = solver_registry.get(solver_name) return solvercls(*args, **kwargs) def wrap_call_log(f, call_dict): """Wraps an existing call log (as dictionary) around f. """ f = fun.logged(f) call_log = fun.dict2call_log(call_dict) if f.call_log: f.call_log.update(call_log) else: f.call_log = call_log return f def wrap_constraints(f, default=None, **kwargs): """Decorates f with all constraints listed in kwargs. constraint_dict may have the following keys: - ``ub_?``: upper bound - ``lb_?``: lower bound - ``range_??``: range' where '?' can be either 'o' (open) or 'c' (closed). The values of constraint_dict are dicts with argname-value pairs. """ if not kwargs: return f # jump table to get the right constraint function jt = {'ub_o': fun.constr_ub_o, 'ub_c': fun.constr_ub_c, 'lb_o': fun.constr_lb_o, 'lb_c': fun.constr_lb_c, 'range_oo': fun.constr_range_oo, 'range_oc': fun.constr_range_oc, 'range_co': fun.constr_range_co, 'range_cc': fun.constr_range_cc} # construct constraint list constraints = [] for constr_name, pars in kwargs.items(): constr_fun = jt[constr_name] for field, bounds in pars.items(): constraints.append(functools.partial(constr_fun, field=field, bounds=bounds)) # wrap function if default is None: @fun.constrained(constraints) @functools.wraps(f) def func(*args, **kwargs): return f(*args, **kwargs) else: @fun.violations_defaulted(default) @fun.constrained(constraints) @functools.wraps(f) def func(*args, **kwargs): return f(*args, **kwargs) return func def _wrap_hard_box_constraints(f, box, default): """Places hard box constraints on the domain of ``f`` and defaults function values if constraints are violated. :param f: the function to be wrapped with constraints :param box: the box, as a dict: ``{'param_name': [lb, ub], ...} :param default: function value to default to when constraints are violated """ return wrap_constraints(f, default, range_oo=box) Optunity-0.2.0/optunity/test/0000755000175000017500000000000012364000746016052 5ustar badnbadn00000000000000Optunity-0.2.0/optunity/test/functions.py0000755000175000017500000000023212356233516020440 0ustar badnbadn00000000000000#! /usr/bin/env python import math import doctest from optunity.functions import * doctest.testfile('functions.py', package='optunity', globs=locals()) Optunity-0.2.0/optunity/test/__init__.py0000644000175000017500000000000012356233516020155 0ustar badnbadn00000000000000Optunity-0.2.0/optunity/test/solvers.py0000755000175000017500000000022612356233516020130 0ustar badnbadn00000000000000#! /usr/bin/env python import math import doctest from optunity.solvers import * doctest.testfile('solvers.py', package='optunity', globs=locals()) Optunity-0.2.0/optunity/__init__.py0000644000175000017500000000232412364000676017207 0ustar badnbadn00000000000000""" Optunity ========== Provides 1. Routines to efficiently optimize hyperparameters 2. Function decorators to implicitly log evaluations, constrain the domain and more. 3. Facilities for k-fold cross-validation to estimate generalization performance. Available modules --------------------- solvers contains all officially supported solvers functions a variety of useful function decorators for hyperparameter tuning cross_validation k-fold cross-validation Available subpackages --------------------- test regression test suite Utilities --------- __version__ Optunity version string __revision__ Optunity revision string __author__ Main authors of the package """ from .api import manual, maximize, minimize, optimize from .api import wrap_call_log, wrap_constraints, make_solver, suggest_solver from .cross_validation import cross_validated, generate_folds from .parallel import pmap __author__ = "Marc Claesen, Jaak Simm and Dusan Popovic" __version__ = "0.2" __revision__ = "0.2.1" __all__ = ['manual', 'maximize', 'minimize', 'optimize', 'wrap_call_log', 'wrap_constraints', 'make_solver', 'suggest_solver', 'cross_validated', 'generate_folds', 'pmap'] Optunity-0.2.0/optunity/solver_registry.py0000644000175000017500000001023312361223120020674 0ustar badnbadn00000000000000#! /usr/bin/env python # Copyright (c) 2014 KU Leuven, ESAT-STADIUS # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions # are met: # # 1. Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # # 2. Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # # 3. Neither name of copyright holders nor the names of its contributors # may be used to endorse or promote products derived from this software # without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR # PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF # LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """Module to take care of registering solvers for use in the main Optunity API. Main functions in this module: * :func:`register_solver` * :func:`manual` * :func:`get` .. moduleauthor:: Marc Claesen """ __all__ = ['get', 'manual', 'register_solver', 'solver_names'] __registered_solvers = {} def __register(cls): global __registered_solvers __registered_solvers[cls.name] = cls def get(solver_name): """Returns the class of the solver registered under given name. :param solver_name: name of the solver :returns: the solver class""" global __registered_solvers return __registered_solvers[solver_name] def manual(): """ Returns the general manual of Optunity, with a brief introduction of all registered solvers. :returns: the manual as a list of strings (lines) """ global __registered_solvers manual = ['Optunity: optimization algorithms for hyperparameter tuning', ' ', 'The following solvers are available:'] for name, cls in __registered_solvers.items(): manual.append(name + ' :: ' + cls.desc_brief) manual.append(' ') manual.append("For a solver-specific manual, include its name in the request.") manual.append("For more detailed info, please consult the Optunity user wiki at:") manual.append("https://github.com/claesenm/optunity/wiki/User-homepage") return manual def solver_names(): """Returns a list of all registered solvers.""" global __registered_solvers return list(__registered_solvers.keys()) def register_solver(name, desc_brief, desc_full): """Class decorator to register a :class:`optunity.solvers.Solver` subclass in the registry. Registered solvers will be available through Optunity's main API functions, e.g. :func:`optunity.make_solver` and :func:`optunity.manual`. :param name: name to register the solver with :param desc_brief: one-line description of the solver :param desc_full: extensive description and manual of the solver returns a list of strings representing manual lines :returns: a class decorator to register solvers in the solver registry The resulting class decorator attaches attributes to the class before registering: :_name: the name using which the solver is registered :_desc_full: extensive description and manual as list of strings (lines) :_desc_brief: attribute with one-line description These attributes will be available as class properties. """ def class_wrapper(cls): cls.name = name cls.desc_brief = desc_brief cls.desc_full = desc_full __register(cls) return cls return class_wrapper Optunity-0.2.0/optunity/piped.py0000755000175000017500000001251212364000677016555 0ustar badnbadn00000000000000#! /usr/bin/env python # Copyright (c) 2014 KU Leuven, ESAT-STADIUS # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions # are met: # # 1. Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # # 2. Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # # 3. Neither name of copyright holders nor the names of its contributors # may be used to endorse or promote products derived from this software # without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR # PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF # LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """This module is for developer use only. It is used to start a communication session. .. warning:: Importing this module should only be done when launching Optunity as a subprocess to access functionality from non-Python environments. Do not import this module as a Python user. .. moduleauthor:: Marc Claesen """ from __future__ import print_function import sys # optunity imports from . import communication as comm from . import functions import optunity if __name__ == '__main__': startup_json = comm.receive() startup_msg = comm.json_decode(startup_json) if startup_msg.get('manual', False): solver_name = startup_msg.get('solver', None) try: manual, solver_names = optunity.api._manual_lines(solver_name) except KeyError: msg = {'error_msg': 'Solver does not exist (' + solver_name + ').'} comm.send(comm.json_encode(msg)) print(startup_msg, file=sys.stderr) exit(1) except EOFError: msg = {'error_msg': 'Broken pipe.'} comm.send(comm.json_encode(msg)) exit(1) msg = {'manual': manual, 'solver_names': solver_names} comm.send(comm.json_encode(msg)) exit(0) elif startup_msg.get('generate_folds', False): import optunity.cross_validation as cv cv_opts = startup_msg['generate_folds'] try: num_instances = cv_opts['num_instances'] except KeyError: msg = {'error_msg': 'number of instances num_instances must be set.'} comm.send(comm.json_encode(msg)) print(startup_msg, file=sys.stderr) exit(1) num_folds = cv_opts.get('num_folds', 10) strata = cv_opts.get('strata', None) clusters = cv_opts.get('clusters', None) num_iter = cv_opts.get('num_iter', 1) idx2cluster = None if clusters: idx2cluster = cv.map_clusters(clusters) folds = [optunity.generate_folds(num_instances, num_folds=num_folds, strata=strata, clusters=clusters, idx2cluster=idx2cluster) for _ in range(num_iter)] msg = {'folds': folds} comm.send(comm.json_encode(msg)) exit(0) else: # solving a given problem mgr = comm.EvalManager() func = optunity.wrap_constraints(comm.make_piped_function(mgr), startup_msg.get('default', None), **startup_msg.get('constraints', {}) ) if startup_msg.get('call_log', False): func = optunity.wrap_call_log(func, startup_msg['call_log']) else: func = functions.logged(func) maximize = startup_msg.get('maximize', True) # instantiate solver try: solver = optunity.make_solver(startup_msg['solver'], **startup_msg['config']) except KeyError: msg = {'error_msg': 'Unable to instantiate solver.'} comm.send(comm.json_encode(msg)) print(startup_msg, file=sys.stderr) exit(1) except EOFError: msg = {'error_msg': 'Broken pipe.'} comm.send(comm.json_encode(msg)) exit(1) # solve and send result try: solution, rslt = optunity.optimize(solver, func, maximize, pmap=mgr.pmap) except EOFError: msg = {'error_msg': 'Broken pipe.'} comm.send(comm.json_encode(msg)) exit(1) result = rslt._asdict() result['solution'] = solution result_json = comm.json_encode(result) comm.send(result_json) exit(0) Optunity-0.2.0/optunity/solvers.py0000644000175000017500000006427312364000232017144 0ustar badnbadn00000000000000#! /usr/bin/env python # Copyright (c) 2014 KU Leuven, ESAT-STADIUS # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions # are met: # # 1. Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # # 2. Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # # 3. Neither name of copyright holders nor the names of its contributors # may be used to endorse or promote products derived from this software # without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR # PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF # LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """Module to take care of registering solvers for use in the main Optunity API. Main classes in this module: * :class:`Solver` * :class:`GridSearch` * :class:`RandomSearch` * :class:`DIRECT` * :class:`NelderMead` * :class:`ParticleSwarm` * :class:`CMA_ES` .. warning:: :class:`NelderMead` is only available if SciPy_ is available. :class:`ParticleSwarm` and :class:`CMA_ES` require DEAP_. .. _SciPy: http://http://www.scipy.org/ .. _DEAP: https://code.google.com/p/deap/ Bibliographic references for some solvers: .. [HANSEN2001] Nikolaus Hansen and Andreas Ostermeier. *Completely derandomized self-adaptation in evolution strategies*. Evolutionary computation, 9(2):159-195, 2001. .. [DEAP2012] Felix-Antoine Fortin, Francois-Michel De Rainville, Marc-Andre Gardner, Marc Parizeau and Christian Gagne, *DEAP: Evolutionary Algorithms Made Easy*, Journal of Machine Learning Research, pp. 2171-2175, no 13, jul 2012. .. moduleauthor:: Marc Claesen """ import itertools import collections import abc import functools import random import operator import math # optunity imports from . import functions as fun from .solver_registry import register_solver _scipy_available = True try: import scipy.optimize except ImportError: _scipy_available = False _numpy_available = True try: import numpy as np except ImportError: _numpy_available = False _deap_available = True try: import deap import deap.creator import deap.base import deap.tools import deap.cma import deap.algorithms except ImportError: _deap_available = False except TypeError: # this can happen because DEAP is in Python 2 # install needs to take proper care of converting # 2 to 3 when necessary _deap_available = False # python version-independent metaclass usage SolverBase = abc.ABCMeta('SolverBase', (object, ), {}) class Solver(SolverBase): """Base class of all Optunity solvers. """ @abc.abstractmethod def optimize(self, f, maximize=True, pmap=map): """Optimizes ``f``. :param f: the objective function :type f: callable :param maximize: do we want to maximizes? :type maximize: boolean :param pmap: the map() function to use :type pmap: callable :returns: - the arguments which optimize ``f`` - an optional solver report, can be None """ pass def maximize(self, f, pmap=map): """Maximizes f. :param f: the objective function :type f: callable :param pmap: the map() function to use :type pmap: callable :returns: - the arguments which optimize ``f`` - an optional solver report, can be None """ return optimize(f, True, pmap=pmap) def minimize(self, f, pmap=map): """Minimizes ``f``. :param f: the objective function :type f: callable :param pmap: the map() function to use :type pmap: callable :returns: - the arguments which optimize ``f`` - an optional solver report, can be None """ return optimize(f, False, pmap=pmap) # http://stackoverflow.com/a/13743316 def _copydoc(fromfunc, sep="\n"): """ Decorator: Copy the docstring of `fromfunc` """ def _decorator(func): sourcedoc = fromfunc.__doc__ if func.__doc__ == None: func.__doc__ = sourcedoc else: func.__doc__ = sep.join([sourcedoc, func.__doc__]) return func return _decorator @register_solver('grid search', 'finds optimal parameter values on a predefined grid', ['Retrieves the best parameter tuple on a predefined grid.', ' ', 'This function requires the grid to be specified via named arguments:', '- names :: argument names', '- values :: list of grid coordinates to test', ' ', 'The solver performs evaluation on the Cartesian product of grid values.', 'The number of evaluations is the product of the length of all value vectors.' ]) class GridSearch(Solver): """ Exhaustive search over the Cartesian product of parameter tuples. Returns x (the tuple which maximizes f) and its score f(x). >>> s = GridSearch(x=[1,2,3], y=[-1,0,1]) >>> best_pars, _ = s.optimize(lambda x, y: x*y) >>> best_pars {'y': 1, 'x': 3} """ def __init__(self, **kwargs): """Initializes the solver with a tuple indicating parameter values. >>> s = GridSearch(x=[1,2], y=[3,4]) >>> s.parameter_tuples {'y': [3, 4], 'x': [1, 2]} """ self._parameter_tuples = kwargs @staticmethod def suggest_from_box(num_evals, **kwargs): pass @property def parameter_tuples(self): """Returns the possible values of every parameter.""" return self._parameter_tuples @_copydoc(Solver.optimize) def optimize(self, f, maximize=True, pmap=map): best_pars = None sortedkeys = sorted(self.parameter_tuples.keys()) f = fun.static_key_order(sortedkeys)(f) if maximize: comp = lambda score, best: score > best else: comp = lambda score, best: score < best tuples = list(zip(*itertools.product(*zip(*sorted(self.parameter_tuples.items()))[1]))) scores = pmap(f, *tuples) if maximize: comp = max else: comp = min best_idx, _ = comp(enumerate(scores), key=operator.itemgetter(1)) best_pars = operator.itemgetter(best_idx)(zip(*tuples)) return dict([(k, v) for k, v in zip(sortedkeys, best_pars)]), None @register_solver('random search', 'random parameter tuples sampled uniformly within box constraints', ['Tests random parameter tuples sampled uniformly within the box constraints.', ' ', 'This function requires the following arguments:', '- num_evals :: number of tuples to test', '- box constraints via keywords: constraints are lists [lb, ub]', ' ', 'This solver performs num_evals function evaluations.', ' ', 'This solver implements the technique described here:', 'Bergstra, James, and Yoshua Bengio. Random search for hyper-parameter optimization. Journal of Machine Learning Research 13 (2012): 281-305.'] ) class RandomSearch(Solver): def __init__(self, num_evals, **kwargs): """Initializes the solver with bounds and a number of allowed evaluations. kwargs must be a dictionary of parameter-bound pairs representing the box constraints. Bounds are a 2-element list: [lower_bound, upper_bound]. >>> s = RandomSearch(x=[0, 1], y=[-1, 2], num_evals=50) >>> s.bounds {'y': [-1, 2], 'x': [0, 1]} >>> s.num_evals 50 """ assert all([len(v) == 2 and v[0] <= v[1] for v in kwargs.values()]), 'kwargs.values() are not [lb, ub] pairs' self._bounds = kwargs self._num_evals = num_evals @staticmethod def suggest_from_box(num_evals, **kwargs): d = dict(kwargs) d['num_evals'] = num_evals return d @property def upper(self, par): """Returns the upper bound of par.""" return self._bounds[par][1] @property def lower(self, par): """Returns the lower bound of par.""" return self._bounds[par][0] @property def bounds(self): """Returns a dictionary containing the box constraints.""" return self._bounds @property def num_evals(self): """Returns the number of evaluations this solver may do.""" return self._num_evals @_copydoc(Solver.optimize) def optimize(self, f, maximize=True, pmap=map): def generate_rand_args(len=1): return [[random.uniform(bounds[0], bounds[1]) for _ in range(len)] for _, bounds in sorted(self.bounds.items())] best_pars = None sortedkeys = sorted(self.bounds.keys()) f = fun.static_key_order(sortedkeys)(f) if maximize: comp = lambda score, best: score > best else: comp = lambda score, best: score < best tuples = generate_rand_args(self.num_evals) scores = pmap(f, *tuples) if maximize: comp = max else: comp = min best_idx, _ = comp(enumerate(scores), key=operator.itemgetter(1)) best_pars = operator.itemgetter(best_idx)(zip(*tuples)) return dict([(k, v) for k, v in zip(sortedkeys, best_pars)]), None @register_solver('direct', 'DIviding RECTangles refinement search strategy', ['This solver implements the technique described here:', 'Jones, Donald R., Cary D. Perttunen, and Bruce E. Stuckman. Lipschitzian optimization without the Lipschitz constant. Journal of Optimization Theory and Applications 79.1 (1993): 157-181.'] ) class Direct(Solver): def __init__(self, num_evals, eps, **kwargs): """Initializes the solver with bounds and a number of allowed evaluations. kwargs must be a dictionary of parameter-bound pairs representing the box constraints. Bounds are a 2-element list: [lower_bound, upper_bound]. """ assert all([len(v) == 2 and v[0] <= v[1] for v in kwargs.values()]), 'kwargs.values() are not [lb, ub] pairs' tup = collections.namedtuple('args',kwargs.keys()) self._lower = tup(**dict([(k, v[0]) for k, v in kwargs.items()])) self._upper = tup(**dict([(k, v[1]) for k, v in kwargs.items()])) self._num_evals = num_evals self._eps = eps def scale_data(self, data): return dict([(k, lb + float(x) * (ub - lb)) for k, x, lb, ub in zip(self.lower._fields, data, self.lower, self.upper)]) @property def tup(self): return self._tup @property def eps(self): return self._eps @property def upper(self, par=None): """Returns the upper bound of par. If par is None, returns all upper bounds.""" if par is None: return self._upper return getattr(self._upper, par) @property def lower(self, par=None): """Returns the lower bound of par. If par is None, returns all lower bounds.""" if par is None: return self._lower return getattr(self._lower, par) @property def bounds(self): """Returns a dictionary containing the box constraints.""" return dict([(k, [lb, ub]) for k, lb, ub in zip(self.lower._fields, self.lower, self.upper)]) @property def num_evals(self): """Returns the number of evaluations this solver may do.""" return self._num_evals @_copydoc(Solver.optimize) def optimize(self, f, maximize=True, pmap=map): def generate_rand_args(): return dict([(par, random.uniform(bounds[0], bounds[1])) for par, bounds in self.bounds.items()]) parameter_tuples = [generate_rand_args() for _ in range(self.num_evals)] best_score = float("-inf") best_pars = None for pars in parameter_tuples: score = f(**pars) if score > best_score: best_score = score best_pars = pars return best_pars, None # no useful statistics to report class NelderMead(Solver): """ Performs Nelder-Mead optimization to minimize f. Requires scipy. In scipy < 0.11.0, scipy.optimize.fmin is used. In scipy >= 0.11.0, scipy.optimize.minimize is used. >>> s = NelderMead(x=1, y=1, xtol=1e-8) #doctest:+SKIP >>> best_pars, _ = s.optimize(lambda x, y: -x**2 - y**2) #doctest:+SKIP >>> [math.fabs(best_pars['x']) < 1e-8, math.fabs(best_pars['y']) < 1e-8] #doctest:+SKIP [True, True] """ def __init__(self, xtol=1e-4, **kwargs): """Initializes the solver with a tuple indicating parameter values. >>> s = NelderMead(x=1, xtol=2) #doctest:+SKIP >>> s.start #doctest:+SKIP {'x': 1} >>> s.xtol #doctest:+SKIP 2 """ if not _scipy_available: raise ImportError('This solver requires SciPy but it is missing.') self._start = kwargs self._xtol = xtol @staticmethod def suggest_from_seed(num_evals, **kwargs): return kwargs @property def xtol(self): """Returns the tolerance.""" return self._xtol @property def start(self): """Returns the starting point.""" return self._start @_copydoc(Solver.optimize) def optimize(self, f, maximize=True, pmap=map): if maximize: f = fun.negated(f) sortedkeys = sorted(self.start.keys()) x0 = [self.start[k] for k in sortedkeys] f = fun.static_key_order(sortedkeys)(f) def func(x): return f(*list(x)) version = scipy.__version__ if int(version.split('.')[1]) >= 11: print('HALP: wrong scipy version') pass # TODO else: xopt = scipy.optimize.fmin(func, np.array(x0), xtol=self.xtol, disp=False) return dict([(k, v) for k, v in zip(sortedkeys, xopt)]), None if _scipy_available: NelderMead = register_solver('nelder-mead', 'simplex method for unconstrained optimization', ['Simplex method for unconstrained optimization', ' ', 'The simplex algorithm is a simple way to optimize a fairly well-behaved function.', 'The function is assumed to be convex. If not, this solver may yield poor solutions.', ' ', 'This solver requires the following arguments:', '- start :: starting point for the solver (through kwargs)', '- xtol :: accuracy up to which to optimize the function (default 1e-4)' ])(NelderMead) class CMA_ES(Solver): """ Covariance Matrix Adaptation Evolutionary Strategy This solver implements the technique described in [HANSEN2001]_. This solver uses an implementation available in the DEAP library [DEAP2012]_. """ def __init__(self, num_generations, sigma=1.0, Lambda=None, **kwargs): """blah""" if not _deap_available: raise ImportError('This solver requires DEAP but it is missing.') if not _numpy_available: raise ImportError('This solver requires NumPy but it is missing.') self._num_generations = num_generations self._start = kwargs self._sigma = sigma self._lambda = Lambda @staticmethod def suggest_from_seed(num_evals, **kwargs): fertility = 4 + 3 * math.log(len(kwargs)) d = dict(kwargs) d['num_generations'] = int(math.ceil(float(num_evals) / fertility)) # num_gen is overestimated # this will require slightly more function evaluations than permitted by num_evals return d @property def num_generations(self): return self._num_generations @property def start(self): """Returns the starting point for CMA-ES.""" return self._start @property def lambda_(self): return self._lambda @property def sigma(self): return self._sigma @_copydoc(Solver.optimize) def optimize(self, f, maximize=True, pmap=map): toolbox = deap.base.Toolbox() if maximize: fit = 1.0 else: fit = -1.0 deap.creator.create("FitnessMax", deap.base.Fitness, weights=(fit,)) Fit = deap.creator.FitnessMax deap.creator.create("Individual", list, fitness=Fit) Individual = deap.creator.Individual if self.lambda_: strategy = deap.cma.Strategy(centroid=self.start.values(), sigma=self.sigma, lambda_=self.lambda_) else: strategy = deap.cma.Strategy(centroid=self.start.values(), sigma=self.sigma) toolbox.register("generate", strategy.generate, Individual) toolbox.register("update", strategy.update) @functools.wraps(f) def evaluate(individual): return (f(**dict([(k, v) for k, v in zip(self.start.keys(), individual)])),) toolbox.register("evaluate", evaluate) toolbox.register("map", pmap) hof = deap.tools.HallOfFame(1) deap.algorithms.eaGenerateUpdate(toolbox=toolbox, ngen=self._num_generations, halloffame=hof, verbose=False) return dict([(k, v) for k, v in zip(self.start.keys(), hof[0])]), None # CMA_ES solver requires deap > 1.0.1 # http://deap.readthedocs.org/en/latest/examples/cmaes.html if _deap_available and _numpy_available: CMA_ES =register_solver('cma-es', 'covariance matrix adaptation evolutionary strategy', ['CMA-ES: covariance matrix adaptation evolutionary strategy', ' ', 'This method requires the following parameters:', '- num_generations :: number of generations to use', '- sigma :: (optional) initial covariance, default 1', '- Lambda :: (optional) measure of reproducibility', '- starting point: through kwargs' ' ', 'This method is described in detail in:', 'Hansen and Ostermeier, 2001. Completely Derandomized Self-Adaptation in Evolution Strategies. Evolutionary Computation' ])(CMA_ES) class ParticleSwarm(Solver): """ This solver uses an implementation available in the DEAP library [DEAP2012]_. """ def __init__(self, num_particles, num_generations, max_speed=None, **kwargs): """blah""" if not _deap_available: raise ImportError('This solver requires DEAP but it is missing.') assert all([len(v) == 2 and v[0] <= v[1] for v in kwargs.values()]), 'kwargs.values() are not [lb, ub] pairs' self._bounds = kwargs self._ttype = collections.namedtuple('ttype', kwargs.keys()) self._num_particles = num_particles self._num_generations = num_generations if max_speed is None: max_speed = 2.0/num_generations self._max_speed = max_speed self._smax = [self.max_speed * (b[1] - b[0]) for _, b in self.bounds.items()] self._smin = map(operator.neg, self.smax) self._toolbox = deap.base.Toolbox() self._toolbox.register("particle", self.generate) self._toolbox.register("population", deap.tools.initRepeat, list, self.toolbox.particle) self._toolbox.register("update", self.updateParticle, phi1=2.0, phi2=2.0) @staticmethod def suggest_from_box(num_evals, **kwargs): d = dict(kwargs) if num_evals > 200: d['num_particles'] = 50 d['num_generations'] = int(math.ceil(float(num_evals) / 50)) elif num_evals > 10: d['num_particles'] = 10 d['num_generations'] = int(math.ceil(float(num_evals) / 10)) else: d['num_particles'] = num_evals d['num_generations'] = 1 return d @property def num_particles(self): return self._num_particles @property def num_generations(self): return self._num_generations @property def toolbox(self): return self._toolbox @property def max_speed(self): return self._max_speed @property def smax(self): return self._smax @property def smin(self): return self._smin @property def bounds(self): return self._bounds @property def ttype(self): return self._ttype def generate(self): part = self._Particle(random.uniform(bounds[0], bounds[1]) for _, bounds in self.bounds.items()) part.speed = [random.uniform(smin, smax) for smin, smax in zip(self.smin, self.smax)] return part def updateParticle(self, part, best, phi1, phi2): u1 = (random.uniform(0, phi1) for _ in range(len(part))) u2 = (random.uniform(0, phi2) for _ in range(len(part))) v_u1 = map(operator.mul, u1, map(operator.sub, part.best, part)) v_u2 = map(operator.mul, u2, map(operator.sub, best, part)) part.speed = list(map(operator.add, part.speed, map(operator.add, v_u1, v_u2))) for i, speed in enumerate(part.speed): if speed < self.smin[i]: part.speed[i] = self.smin[i] elif speed > self.smax[i]: part.speed[i] = self.smax[i] part[:] = list(map(operator.add, part, part.speed)) @_copydoc(Solver.optimize) def optimize(self, f, maximize=True, pmap=map): @functools.wraps(f) def evaluate(individual): return (f(**dict([(k, v) for k, v in zip(self.bounds.keys(), individual)])),) self._toolbox.register("evaluate", evaluate) self._toolbox.register("map", pmap) if maximize: fit = 1.0 else: fit = -1.0 deap.creator.create("FitnessMax", deap.base.Fitness, weights=(fit,)) FitnessMax = deap.creator.FitnessMax deap.creator.create("Particle", list, fitness=FitnessMax, speed=list, best=None) self._Particle = deap.creator.Particle pop = self.toolbox.population(self.num_particles) best = None for g in range(self.num_generations): fitnesses = self.toolbox.map(self.toolbox.evaluate, pop) for part, fitness in zip(pop, fitnesses): part.fitness.values = fitness if not part.best or part.best.fitness < part.fitness: part.best = self._Particle(part) part.best.fitness.values = part.fitness.values if not best or best.fitness < part.fitness: best = self._Particle(part) best.fitness.values = part.fitness.values for part in pop: self.toolbox.update(part, best) return dict([(k, v) for k, v in zip(self.bounds.keys(), best)]), None # PSO solver requires deap > 0.7 # http://deap.gel.ulaval.ca/doc/dev/examples/pso_basic.html # https://code.google.com/p/deap/source/browse/examples/pso/basic.py?name=dev if _deap_available: ParticleSwarm = register_solver('particle swarm', 'particle swarm optimization', ['Maximizes the function using particle swarm optimization.', ' ', 'This is a two-phase approach:', '1. Initialization: randomly initializes num_particles particles.', ' Particles are randomized uniformly within the box constraints.', '2. Iteration: particles move during num_generations iterations.', ' Movement is based on their velocities and mutual attractions.', ' ', 'This function requires the following arguments:', '- num_particles: number of particles to use in the swarm', '- num_generations: number of iterations used by the swarm', '- max_speed: maximum speed of the particles in each direction (in (0, 1])', '- box constraints via key words: constraints are lists [lb, ub]', ' ', 'This solver performs num_particles*num_generations function evaluations.' ])(ParticleSwarm) Optunity-0.2.0/optunity/partest.py0000644000175000017500000000057512363461521017137 0ustar badnbadn00000000000000from __future__ import print_function import optunity import optunity.parallel def f(x, y): return x * y s = optunity.solvers.GridSearch(x=[1,2,3], y=[1,2,3]) result = s.optimize(f) result = s.optimize(f, pmap=optunity.parallel.pmap) s = optunity.solvers.ParticleSwarm(5, 5, x=[1, 2], y=[0, 1]) result = s.optimize(f) result2 = s.optimize(f, pmap=optunity.parallel.pmap) Optunity-0.2.0/optunity/example.py0000644000175000017500000000103512360554576017112 0ustar badnbadn00000000000000#!/usr/bin/env python import optunity def f(x, y): return -x ** 2 - y ** 2 pso_solver = optunity.make_solver('particle swarm', num_particles=10, max_speed=1, num_generations=10, x=[-1, 1], y=[1, 3]) result, details = optunity.maximize(pso_solver, f) cma_solver = optunity.make_solver('cma-es', num_generations=20, centroid={'x': 0, 'y': 0}, sigma=1) result, details = optunity.maximize(cma_solver, f) Optunity-0.2.0/optunity/parallel.py0000644000175000017500000001034412363510441017240 0ustar badnbadn00000000000000#! /usr/bin/env python # Copyright (c) 2014 KU Leuven, ESAT-STADIUS # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions # are met: # # 1. Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # # 2. Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # # 3. Neither name of copyright holders nor the names of its contributors # may be used to endorse or promote products derived from this software # without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR # PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF # LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. import itertools import functools import multiprocessing import threading import copy import collections __all__ = ['pmap', 'Future'] def _fun(f, q_in, q_out): while True: i, x = q_in.get() if i is None: break value = f(*x) d = None keys = None if hasattr(f, 'call_log'): k, v = f.call_log.items()[-1] d = (tuple(k), v) keys = k._fields q_out.put((i, value, d, keys)) # http://stackoverflow.com/a/16071616 def pmap(f, *args): """Parallel map using multiprocessing. :param f: the callable :param args: arguments to f, as iterables :returns: a list containing the results """ nprocs = multiprocessing.cpu_count() q_in = multiprocessing.Queue(1) q_out = multiprocessing.Queue() proc = [multiprocessing.Process(target=_fun, args=(f, q_in, q_out)) for _ in range(nprocs)] for p in proc: p.daemon = True p.start() sent = [q_in.put((i, x)) for i, x in enumerate(zip(*args))] [q_in.put((None, None)) for _ in range(nprocs)] res = [q_out.get() for _ in range(len(sent))] [p.join() for p in proc] # FIXME: strong coupling between pmap and functions.logged if hasattr(f, 'call_log'): keys = res[0][3] if f.argtuple is None: f.argtuple = collections.namedtuple('args', keys) for _, _, d, _ in sorted(res): k, v = d f.call_log[f.argtuple(*k)] = v return [x for i, x, _, _ in sorted(res)] # http://code.activestate.com/recipes/84317-easy-threading-with-futures/ class Future: def __init__(self,func,*param): # Constructor self.__done=0 self.__result=None self.__status='working' self.__S=threading.Semaphore(0) # Run the actual function in a separate thread self.__T=threading.Thread(target=self.Wrapper, args=(func, param)) self.__T.setName("FutureThread") self.__T.daemon=True self.__T.start() def __repr__(self): return '' def __call__(self): try: self.__S.acquire() # We deepcopy __result to prevent accidental tampering with it. a=copy.deepcopy(self.__result) finally: self.__S.release() return a def join(self): self.__T.join() def Wrapper(self, func, param): # Run the actual function, and let us housekeep around it # try: self.__result=func(*param) # except: # self.__result="Exception raised within Future" self.__status=`self.__result` self.__S.release() if __name__ == '__main__': pass Optunity-0.2.0/optunity/communication.py0000644000175000017500000001453612363433533020326 0ustar badnbadn00000000000000#! /usr/bin/env python # Author: Marc Claesen # # Copyright (c) 2014 KU Leuven, ESAT-STADIUS # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions # are met: # # 1. Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # # 2. Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # # 3. Neither name of copyright holders nor the names of its contributors # may be used to endorse or promote products derived from this software # without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR # PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF # LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. from __future__ import print_function import json import sys import itertools from . import functions from . import parallel import multiprocessing import threading __DEBUG = False def json_encode(data): """Encodes given data in a JSON string.""" return json.dumps(data) def json_decode(data): """Decodes given JSON string and returns its data. >>> orig = {1: 2, 'a': [1,2]} >>> data = json_decode(json_encode(orig)) >>> data[str(1)] 2 >>> data['a'] [1, 2] """ return json.loads(data) def send(data, channel=sys.stdout): """Writes data to channel and flushes.""" print(data, file=channel) channel.flush() return None def receive(channel=sys.stdin): """Reads data from channel.""" line = channel.readline()[:-1] if not line: raise EOFError("Unexpected end of communication.") return line class EvalManager(object): def __init__(self): # are we doing a parallel function evaluation? self._vectorized = False # the queue used for parallel evaluations self._queue = None # lock to use to add evaluations to the queue self._add_lock = multiprocessing.Lock() # lock to get results self._get_lock = multiprocessing.Lock() # used to check whether Future started running self._semaphore = None # used to signal Future's to get their result self._processed_semaphore = None @property def cv(self): return self._cv @property def semaphore(self): return self._semaphore @property def processed_semaphore(self): return self._processed_semaphore def pmap(self, f, *args): self._queue = [] self._vectorized = True self._semaphore = multiprocessing.Semaphore(0) self._processed_semaphore = multiprocessing.Semaphore(0) # make sure correct evaluations lead to counter increments def wrap(*args): result = f(*args) # signal mgr to add next future self.semaphore.release() return result # create list of futures futures = [] for ar in zip(*args): futures.append(parallel.Future(wrap, *ar)) try: self.semaphore.acquire() except functions.MaximumEvaluationsException: if not len(self.queue): # FIXME: some threads may be running atm raise break # process queue self.flush_queue() # notify all waiting futures for _ in range(len(self.queue)): self.processed_semaphore.release() # gather results results = [f() for f in futures] for f in futures: f.join() return results def pipe_eval(self, **kwargs): json_data = json_encode(kwargs) send(json_data) json_reply = receive() decoded = json_decode(json_reply) if decoded.get('error', False): # TODO: allow error handling higher up? sys.stderr('ERROR: ' + decoded['error']) sys.exit(1) return decoded['value'] def add_to_queue(self, **kwargs): try: self.add_lock.acquire() self.queue.append(kwargs) idx = len(self.queue) - 1 finally: self.add_lock.release() return idx @property def vectorized(self): return self._vectorized @property def queue(self): return self._queue @property def add_lock(self): return self._add_lock def get(self, number): try: self._get_lock.acquire() value = self._results[number] finally: self._get_lock.release() return value def flush_queue(self): self._results = [] if self.queue: json_data = json_encode(self.queue) send(json_data) json_reply = receive() decoded = json_decode(json_reply) if decoded.get('error', False): sys.stderr('ERROR: ' + decoded['error']) sys.exit(1) self._results = decoded['values'] return None def make_piped_function(mgr): def piped_function_eval(**kwargs): """Returns a function evaluated through a pipe with arguments args. args must be a namedtuple.""" if mgr.vectorized: # add to mgr queue number = mgr.add_to_queue(**kwargs) # signal mgr to continue mgr.semaphore.release() # wait for results mgr.processed_semaphore.acquire() return mgr.get(number) else: return mgr.pipe_eval(**kwargs) return piped_function_eval if __name__ == '__main__': import doctest doctest.testmod() Optunity-0.2.0/optunity/score_functions.py0000644000175000017500000001006112361417332020646 0ustar badnbadn00000000000000#! /usr/bin/env python # Author: Marc Claesen # # Copyright (c) 2014 KU Leuven, ESAT-STADIUS # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions # are met: # # 1. Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # # 2. Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # # 3. Neither name of copyright holders nor the names of its contributors # may be used to endorse or promote products derived from this software # without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR # PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF # LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. import math def mse(y, yhat): """Returns the mean squared error between y and yhat. :param y: true function values :param yhat: predicted function values :returns: .. math:: \\frac{1}{n} \sum_{i=1}^n \\big[(\hat{y}-y)^2\\big] Lower is better.""" return float(sum([(l - p) ** 2 for l, p in zip(y, yhat)])) / len(y) def accuracy(y, yhat): """Returns the accuracy. Higher is better. :param y: true function values :param yhat: predicted function values """ return float(len(filter(lambda x: x[0] == x[1], zip(y, yhat)))) / len(y) def log_loss(y, yhat): """Returns the log loss between labels and predictions. :param y: true function values :param yhat: predicted function values :returns: .. math:: -\\frac{1}{n}\sum_{i=1}^n\\big[y \\times \log \hat{y}+(1-y) \\times \log (1-\hat{y})\\big] y must be a binary vector, e.g. elements in {True, False} yhat must be a vector of probabilities, e.g. elements in [0, 1] Lower is better. """ loss = sum([math.log(pred) for _, pred in filter(lambda i: i[0], zip(y, yhat))]) loss += sum([math.log(1 - pred) for _, pred in filter(lambda i: not i[0], zip(y, yhat))]) return -loss def brier_score(y, yhat): """Returns the Brier score between y and yhat. :param y: true function values :param yhat: predicted function values :returns: .. math:: \\frac{1}{n} \sum_{i=1}^n \\big[(\hat{y}-y)^2\\big] y must be a boolean vector, e.g. elements in {True, False} yhat must be a vector of probabilities, e.g. elements in [0, 1] Lower is better. """ return sum([(yp - float(yt)) ** 2 for yt, yp in zip(y, yhat)]) / len(y) def pu_score(y, yhat): """ Returns a score used for PU learning as introduced in [LEE2003]_. :param y: true function values :param yhat: predicted function values :returns: .. math:: \\frac{P(\hat{y}=1 | y=1)^2}{P(\hat{y}=1)} y and yhat must be boolean vectors. Higher is better. .. [LEE2003] Wee Sun Lee and Bing Liu. Learning with positive and unlabeled examples using weighted logistic regression. In Proceedings of the Twentieth International Conference on Machine Learning (ICML), 2003. """ num_pos = sum(y) p_pred_pos = float(sum(yhat)) / len(y) if p_pred_pos == 0: return 0.0 tp = sum([all(x) for x in zip(y, yhat)]) return tp * tp / (num_pos * num_pos * p_pred_pos) Optunity-0.2.0/optunity/util.py0000644000175000017500000000362712356720076016440 0ustar badnbadn00000000000000#! /usr/bin/env python # Author: Marc Claesen # # Copyright (c) 2014 KU Leuven, ESAT-STADIUS # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions # are met: # # 1. Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # # 2. Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # # 3. Neither name of copyright holders nor the names of its contributors # may be used to endorse or promote products derived from this software # without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR # PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF # LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. import collections def DocumentedNamedTuple(docstring, *ntargs): """Factory function to construct collections.namedtuple with a docstring. Useful to attach meta-information to data structures. Inspired by http://stackoverflow.com/a/1606478""" nt = collections.namedtuple(*ntargs) class NT(nt): __doc__ = docstring return NT Optunity-0.2.0/optunity/cross_validation.py0000644000175000017500000003217712363556505021032 0ustar badnbadn00000000000000#! /usr/bin/env python # Copyright (c) 2014 KU Leuven, ESAT-STADIUS # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions # are met: # # 1. Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # # 2. Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # # 3. Neither name of copyright holders nor the names of its contributors # may be used to endorse or promote products derived from this software # without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR # PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF # LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """This module contains various provisions for cross-validation. The main functions in this module are: * :func:`cross_validated` * :func:`generate_folds` * :func:`strata_by_labels` * :func:`random_permutation` .. moduleauthor:: Marc Claesen """ import math import random import itertools as it import functools import collections import operator as op __all__ = ['select', 'random_permutation', 'map_clusters', 'cross_validated', 'generate_folds', 'strata_by_labels'] def select(collection, indices): """Selects the subset specified by indices from collection.""" return [collection[i] for i in indices] # https://docs.python.org/2/library/itertools.html#itertools.permutations def random_permutation(data): """Returns a list containing a random permutation of ``r`` elements out of ``data``. :param data: an iterable containing the elements to permute over :returns: returns a list containing permuted entries of ``data``. """ d = data[:] random.shuffle(d) return d def map_clusters(clusters): """Maps data instance indices to cluster indices. :param clusters: list of lists of instance indices :returns: a dictionary mapping instance indices to clusters """ idx2cluster = collections.defaultdict(collections.deque) if clusters: for cluster, indices in enumerate(clusters): for index in indices: idx2cluster[index].append(cluster) return idx2cluster def strata_by_labels(labels): """Constucts a list of strata (lists) based on unique values of ``labels``. :param labels: iterable, identical values will end up in identical strata :returns: the strata, as a list of lists """ return [list(zip(*g)[0]) for _, g in it.groupby(enumerate(labels), op.itemgetter(1))] # TODO: implement support for clusters def generate_folds(num_rows, num_folds=10, strata=None, clusters=None, idx2cluster=None): """Generates folds for a given number of rows. :param num_rows: number of data instances :param num_folds: number of folds to use (default 10) :param strata: (optional) list of lists to indicate different sampling strata. Not all rows must be in a stratum. The number of rows per stratum must be larger than or equal to num_folds. :param clusters: (optional) list of lists indicating clustered instances. Clustered instances must be placed in a single fold to avoid information leaks. :param idx2cluster: (optional) mapping of instance indices to cluster ids. :returns: a list of folds, each fold is a list of instance indices .. warning:: Returned folds are not necessarily of the same size, but should be comparable. Size differences may grow for large numbers of (small) strata. """ # FIXME: current partitioning has some issues # fold sizes not necessarily (close to) equal # if many small strata exist def get_folds(rows, num_folds, require=False): """Partitions rows in num_folds. If require is true, len(rows) > num_folds or an exception is raised. """ if require and num_folds > len(rows): raise ValueError folds = [None] * num_folds idx = random_permutation(rows) for fold in range(num_folds): fold_size = int(len(idx) / (num_folds - fold)) folds[fold] = idx[:fold_size] del idx[:fold_size] # permute so the largest folds are not always at the back return random_permutation(folds) if clusters and not idx2cluster: idx2cluster = map_clusters(clusters) if strata: # stratified cross-validation ## keep lists per stratum + 1 extra for no-care instances permuted_strata = map(random_permutation, strata) nocares = list(set(range(num_rows)) - set(it.chain(*strata))) # we do not require points of each stratum in each fold, # since strata can be smaller than number of folds folds_per_stratum = map(lambda x: get_folds(x, num_folds, False), permuted_strata) # nocare points need not be in every fold folds_nocare = get_folds(nocares, num_folds, False) # merge folds across strata folds_per_stratum.append(folds_nocare) folds = [list(it.chain(*x)) for x in zip(*folds_per_stratum)] else: # no stratification required folds = get_folds(range(num_rows), num_folds, True) return folds def mean(x): return float(sum(x)) / len(x) def identity(x): return x class cross_validated_callable(object): """Function decorator that takes care of cross-validation. Evaluations of the decorated function will always return a cross-validated estimate of generalization performance. :param x: data to be used for cross-validation :param num_folds: number of cross-validation folds (default 10) :param y: (optional) labels to be used for cross-validation. If specified, len(labels) must equal len(x) :param strata: (optional) strata to account for when generating folds. Strata signify instances that must be spread across folds. Not every instance must be in a stratum. Specify strata as a list of lists of instance indices. :param folds: (optional) prespecified cross-validation folds to be used (list of lists). :param num_iter: (optional) number of iterations to use (default 1) :param regenerate_folds: (optional) whether or not to regenerate folds on every evaluation (default false) :param clusters: (optional) clusters to account for when generating folds. Clusters signify instances that must be assigned to the same fold. Not every instance must be in a cluster. Specify clusters as a list of lists of instance indices. :param reduce: function to aggregate scores of different folds (default: mean) Use :func:`cross_validated` to create instances of this class. """ def __init__(self, f, x, num_folds=10, y=None, strata=None, folds=None, num_iter=1, regenerate_folds=False, clusters=None, reduce=mean): self._x = x self._y = y self._strata = strata self._clusters = clusters self._idx2cluster = map_clusters(clusters) # TODO: sanity check between strata & clusters? define what is allowed self._regenerate_folds = regenerate_folds self._f = f self._reduce = reduce if folds: assert (len(folds) == num_iter), 'Number of fold sets does not equal num_iter.' assert (len(folds[0] == num_folds)), 'Number of folds does not match num_folds.' self._folds = folds else: self._folds = [generate_folds(len(x), num_folds, self.strata, self.clusters, self.idx2cluster) for _ in range(num_iter)] functools.update_wrapper(self, f) @property def reduce(self): """The aggregation function.""" return self._reduce @property def f(self): """The decorated function.""" return self._f @property def folds(self): """The cross-validation folds.""" return self._folds @property def strata(self): """Strata that were used to compute folds.""" return self._strata @property def clusters(self): """Clusters that were used to compute folds.""" return self._clusters @property def idx2cluster(self): """A mapping of data instances to cluster ids. cluster ids are stored in a list, since single instances may occur in several clusters.""" return self._idx2cluster @property def x(self): """The data that is used for cross-validation.""" return self._x @property def y(self): """The labels that are used for cross-validation.""" return self._y @property def num_folds(self): """Number of cross-validation folds.""" return len(self.folds[0]) @property def num_iter(self): """Number of cross-validation iterations.""" return len(self.folds) @property def regenerate_folds(self): """Whether or not folds are regenerated for each function evaluation.""" return self._regenerate_folds def __call__(self, *args, **kwargs): if self.regenerate_folds: self._folds = [generate_folds(len(x), self.num_folds, self.strata) for _ in range(self.num_iter)] scores = [] for folds in self.folds: for fold in range(self.num_folds): rows_test = folds[fold] rows_train = list(it.chain(*[folds[i] for i in range(self.num_folds) if not i == fold])) kwargs['x_train'] = select(self.x, rows_train) kwargs['x_test'] = select(self.x, rows_test) if not self.y is None: # dealing with a supervised algorithm kwargs['y_train'] = select(self.y, rows_train) kwargs['y_test'] = select(self.y, rows_test) scores.append(self.f(*args, **kwargs)) return self.reduce(scores) def cross_validated(x, num_folds=10, y=None, strata=None, folds=None, num_iter=1, regenerate_folds=False, clusters=None, aggregator=mean): """Function decorator to perform cross-validation as configured. :param x: data to be used for cross-validation :param num_folds: number of cross-validation folds (default 10) :param y: (optional) labels to be used for cross-validation. If specified, len(labels) must equal len(x) :param strata: (optional) strata to account for when generating folds. Strata signify instances that must be spread across folds. Not every instance must be in a stratum. Specify strata as a list of lists of instance indices. :param folds: (optional) prespecified cross-validation folds to be used (list of lists). :param num_iter: (optional) number of iterations to use (default 1) :param regenerate_folds: (optional) whether or not to regenerate folds on every evaluation (default false) :param clusters: (optional) clusters to account for when generating folds. Clusters signify instances that must be assigned to the same fold. Not every instance must be in a cluster. Specify clusters as a list of lists of instance indices. :param aggregator: function to aggregate scores of different folds (default: mean) :returns: a :class:`cross_validated_callable` with the proper configuration. """ def wrapper(f): cv_callable = cross_validated_callable(f, x, num_folds, y, strata, folds, num_iter, regenerate_folds, clusters, aggregator) return cv_callable return wrapper if __name__ == '__main__': x = list(range(10)) clusters = [[1,2],[3,4,5]] @cross_validated(x, num_folds=3, num_iter=2, clusters=clusters) def f1(woops, x_train, x_test): '''floopsie docstring''' print(x_train) return 0 print(f1.folds) result = f1(woops='blah') print(result) def f(x, y, z): return x + y + z def f2(**kwargs): kwargs['z'] = 2 return f(**kwargs) print(str(f2(x=1, y=2))) @cross_validated(list(range(20)), num_folds=10, num_iter=2, strata=[[1,2,3],[6,7,8,9]]) def f1(woops, x_train, x_test): '''floopsie docstring''' print(x_train) return 0 Optunity-0.2.0/PKG-INFO0000644000175000017500000000431712364000746014302 0ustar badnbadn00000000000000Metadata-Version: 1.0 Name: Optunity Version: 0.2.0 Summary: Optimization routines for hyperparameter tuning. Home-page: http://optunity.readthedocs.org Author: Marc Claesen Author-email: marc.claesen@esat.kuleuven.be License: LICENSE.txt Description: =========== Optunity =========== Optunity is a library containing various optimizers for hyperparameter tuning. Hyperparameter tuning is a recurrent problem in many machine learning tasks, both supervised and unsupervised. Tuning examples include optimizing regularization or kernel parameters. From an optimization point of view, the tuning problem can be considered as follows: the objective function is non-convex, non-differentiable and typically expensive to evaluate. This package provides several distinct approaches to solve such problems including some helpful facilities such as cross-validation and a plethora of score functions. The Optunity library is implemented in Python and allows straightforward integration in other machine learning environments, including R and MATLAB. To get started with Optunity on Linux, issue the following commands:: git clone https://github.com/claesenm/optunity.git echo "export PYTHONPATH=$PYTHONPATH:$(pwd)/optunity" >> ~/.bashrc Afterwards, importing ``optunity`` should work in Python:: #!/usr/bin/env python import optunity Optunity is developed at the STADIUS lab of the dept. of electrical engineering at KU Leuven (ESAT). Optunity is free software, using a BSD license. For more information, please refer to the following pages: http://optunity.readthedocs.org/en/latest/ Contributors ============ The main contributors to Optunity are: * Marc Claesen: framework design & implementation, communication infrastructure, MATLAB wrapper and a variety of solvers. * Jaak Simm: R wrapper. * Dusan Popovic: genetic algorithm solver. Platform: UNKNOWN Optunity-0.2.0/wrappers/0000755000175000017500000000000012364000746015043 5ustar badnbadn00000000000000Optunity-0.2.0/wrappers/matlab/0000755000175000017500000000000012364000746016303 5ustar badnbadn00000000000000Optunity-0.2.0/wrappers/matlab/example.m0000644000175000017500000001156112363436434020126 0ustar badnbadn00000000000000close all; clear all; drawfig = true; %% target function: f(x,y) = - x^2 - y^2 offx = rand(); offy = rand(); f = @(pars) - (offx+pars.x)^2 - (offy+pars.y)^2; %% cross-validation example strata = {[1,2,3], [6,7,8,9]}; folds = optunity.generate_folds(20, 'num_folds', 10, 'num_iter', 2, 'strata', strata); %% optimize using grid-search grid_solver = optunity.make_solver('grid search','x', -5:0.5:5, 'y', -5:0.5:5); [grid_solution, grid_details] = optunity.maximize(grid_solver, f, 'return_call_log', true); %% optimize using random-search rnd_solver = optunity.make_solver('random search', 'x', [-5, 5], 'y', [-5, 5], 'num_evals', 400); [rnd_solution, rnd_details] = optunity.maximize(rnd_solver, f, 'return_call_log', true); %% check if the nelder-mead solver is available in the list of solvers solvers = optunity.manual(); % obtain a list of available solvers nm_available = any(arrayfun(@(x) strcmp(x, 'nelder-mead'), solvers)); %% optimize using nelder-mead if it is available if nm_available nm_solver = optunity.make_solver('nelder-mead', 'x', 4,'y', -4, 'xtol', 1e-4); [nm_solution, nm_details] = optunity.maximize(nm_solver, f, 'return_call_log', true); end %% check if PSO is available pso_available = any(arrayfun(@(x) strcmp(x, 'particle swarm'), solvers)); if pso_available pso_solver = optunity.make_solver('particle swarm', 'num_particles', 5, 'num_generations', 30, ... 'x', [-5, 5], 'y', [-5, 5], 'max_speed', 0.03); [pso_solution, pso_details] = optunity.maximize(pso_solver, f, 'return_call_log', true); end %% check if CMA-ES is available cma_available = any(arrayfun(@(x) strcmp(x, 'cma-es'), solvers)); if cma_available cma_solver = optunity.make_solver('cma-es', 'num_generations', 25, ... 'sigma', 5, 'x', 2, 'y', 4); [cma_solution, cma_details] = optunity.maximize(cma_solver, f, 'return_call_log', true); end %% draw a figure to illustrate the call log of all solvers if drawfig figure; hold on; plot(grid_details.call_log.args.x, grid_details.call_log.args.y, 'r+','LineWidth', 2); plot(rnd_details.call_log.args.x, rnd_details.call_log.args.y, 'k+','LineWidth', 2); if nm_available plot(nm_details.call_log.args.x, nm_details.call_log.args.y, 'm', 'LineWidth', 3); end if pso_available plot(pso_details.call_log.args.x, pso_details.call_log.args.y, 'bo', 'LineWidth', 2); end if cma_available plot(cma_details.call_log.args.x, cma_details.call_log.args.y, 'go', 'LineWidth', 2); end [X,Y] = meshgrid(-5:0.1:5); Z = arrayfun(@(idx) f(struct('x',X(idx),'y',Y(idx))), 1:numel(X)); Z = reshape(Z, size(X,1), size(X,1)); contour(X,Y,Z); axis square; xlabel('x'); ylabel('y'); title('f(x,y) = -x^2-y^2'); axis([-5.5, 5.5, -5.5, 5.5]) legends = {['grid search (',num2str(grid_details.stats.num_evals),' evals)'], ... ['random search (',num2str(rnd_details.stats.num_evals),' evals)'], ... }; if nm_available legends{end+1} = ['Nelder-Mead (',num2str(nm_details.stats.num_evals),' evals)']; end if pso_available legends{end+1} = ['particle swarm (',num2str(pso_details.stats.num_evals),' evals)']; end if cma_available legends{end+1} = ['CMA-ES (',num2str(cma_details.stats.num_evals),' evals)']; end legend(legends, -1); num_evals = [grid_details.stats.num_evals, rnd_details.stats.num_evals]; optima = [grid_details.optimum, rnd_details.optimum]; ticks = {'grid search', 'random search'}; if nm_available num_evals(end+1) = nm_details.stats.num_evals; optima(end+1) = nm_details.optimum; ticks{end+1} = 'Nelder-Mead'; end if pso_available num_evals(end+1) = pso_details.stats.num_evals; optima(end+1) = pso_details.optimum; ticks{end+1} = 'particle swarm'; end if cma_available num_evals(end+1) = cma_details.stats.num_evals; optima(end+1) = cma_details.optimum; ticks{end+1} = 'CMA-ES'; end figure; hold on; optima(optima~=0) = log10(abs(optima(optima~=0))); bar(optima); set(gca,'XTick', 1:numel(optima), 'XTickLabel',ticks); xlabel('solver'); ylabel('log10(error) or 0 if exact'); end %% grid-search with constraints and defaulted function value -> see call log s_oo1 = optunity.make_solver('grid search', 'x', -5:0.5:5, 'y', -5:0.5:5); constraints = struct('ub_o', struct('x', 3)); [constr_solution, constr_details] = s_oo1.maximize(f, ... 'return_call_log', true, 'constraints', constraints, 'default', -100); %% grid-search with warm start: already evaluated grid -> warm_nevals = 0 s_oo2 = optunity.make_solver('grid search', 'x', [1, 2], 'y', [1, 2]); call_log = struct('args',struct('x',[1 1 2 2], 'y', [1 2 1 2]), ... 'values',[1 2 3 4]); [warm_solution, warm_details] = ... s_oo2.maximize(f, ... 'return_call_log', true, 'call_log', call_log);Optunity-0.2.0/wrappers/matlab/+optunity/0000755000175000017500000000000012364000746020251 5ustar badnbadn00000000000000Optunity-0.2.0/wrappers/matlab/+optunity/maximize.m0000644000175000017500000000500412363146345022256 0ustar badnbadn00000000000000function [solution, details] = maximize( solver, f, varargin) %MAXIMIZE: Maximizes f using the given solver and extra options. % % This function accepts the following arguments: % - solver: an Optunity solver, as generated by optunity.make_solver() % - f: the objective function to be maximized % - varargin: a list of optional key:value pairs % - constraints: a list of domain constraints on f (see details below) % - default: default function value if constraints are violated % - call_log: struct representing an existing call log of f % - return_call_log: (boolean) whether or not to return a call log % % Constraints on the domain of f can be formulated via a struct. % The following constraints are available: % - ub_{oc}: upper bound (open or closed) % - lb_{oc}: lower bound (open or closed) % - range_{oc}{oc}: lower and upper bound (open or closed x2) % To use constraints, create a struct with the appropriate fields. The % values are new structs mapping argument names to their constraint. % Example: constrain argument 'x' to the range (1, 3]: % constraints = struct('range_oc', struct('x', [1, 3])); %% process varargin defaults = struct('constraints', NaN, ... 'call_log', NaN, ... 'return_call_log', false, ... 'default',NaN); options = optunity.process_varargin(defaults, varargin); %% launch SOAP subprocess [m2py, py2m, stderr, subprocess, cleaner] = optunity.comm.launch(); pipe_send = @(data) optunity.comm.writepipe(m2py, optunity.comm.json_encode(data)); pipe_receive = @() optunity.comm.json_decode(optunity.comm.readpipe(py2m)); %% initialize solver msg = struct('solver',solver.name,'config',solver.config,'return_call_log',options.return_call_log); if isstruct(options.constraints) msg.constraints = options.constraints; if ~isnan(options.default) msg.default = options.default; end end if isstruct(options.call_log) msg.call_log = options.call_log; end pipe_send(msg); %% iteratively send function evaluation results until solved reply = struct(); while true reply = pipe_receive(); if isfield(reply, 'solution') || isfield(reply, 'error_msg') break; end if iscell(reply) results = zeros(numel(reply), 1); parfor ii=1:numel(reply) results(ii) = f(reply{ii}); end msg = struct('values', results); else msg = struct('value', f(reply)); end pipe_send(msg); end if isfield(reply, 'error_msg') error(['Error: ', reply.error_msg]); end solution = reply.solution; details = reply; endOptunity-0.2.0/wrappers/matlab/+optunity/+comm/0000755000175000017500000000000012364000746021257 5ustar badnbadn00000000000000Optunity-0.2.0/wrappers/matlab/+optunity/+comm/json_encode.m0000644000175000017500000000240412356233516023727 0ustar badnbadn00000000000000function [ json ] = json_encode( struct ) %JSON_ENCODE Encodes the given struct in json format. if isstruct(struct) fields = fieldnames(struct); strings = arrayfun(@(x) ['"',fields{x},'": ', ... optunity.comm.json_encode(struct.(fields{x}))], ... 1:numel(fields),'UniformOutput',false); json = ['{',strjoin(strings,', '),'}']; elseif ischar(struct) json = ['"',struct,'"']; elseif numel(struct) > 1 strings = arrayfun(@(x) optunity.comm.json_encode(x), struct,'UniformOutput',false); json = ['[', strjoin(strings,', '),']']; elseif isnumeric(struct) json = num2str(struct); elseif islogical(struct) if struct json = 'true'; else json = 'false'; end elseif iscell(struct) strs = cellfun(@(x) optunity.comm.json_encode(x), struct, 'UniformOutput', false); json = strjoin(strs, ', '); else error('UNKNOWN DATA'); end end function str = strjoin(data, delim) if iscell(data) str = cellfun(@(x) [x, delim], data, 'UniformOutput', false); else error('NOT IMPLEMENTED!'); % str = arrayfun(@(x) [x, delim], data, 'UniformOutput', false); end % str cat = str{1}; for ii=2:numel(str) cat = [cat, str{ii}]; end % str = cell2mat(str); str = cat(1:end-numel(delim)); endOptunity-0.2.0/wrappers/matlab/+optunity/+comm/readpipe.m0000644000175000017500000000033612356314536023236 0ustar badnbadn00000000000000function [ content ] = readpipe( pipe ) %READPIPE Reads data chunks from Optunity over its stdout pipe. content = char(pipe.readLine()); if numel(content) == 0 error('Broken pipe: did not receive any data.'); end end Optunity-0.2.0/wrappers/matlab/+optunity/+comm/launch.m0000644000175000017500000000265312360556172022722 0ustar badnbadn00000000000000function [ m2py, py2m, stderr, handle, cleaner ] = launch() %LAUNCH Wrapper around all logic involving the launching of Optunity. % Optunity is launched through a Java Runtime().exec() call. % To enable Optunity to locate installed libraries and necessary % dependencies, we must pass Python's paths explicitly to the subprocess % environment. % % This function returns stdin, stdout, stderr and a handler of the % Optunity subprocess. % Destruction of the subprocess must be done manually. % hack to fix empty paths when spawning Optunity % find the current path used by python % necessary to pass as an env variable when launching Optunity persistent env if isempty(env) [~, pathstr] = system('python -c "import sys; print(sys.path)"'); pathstr = pathstr(pathstr ~= ''''); pathstr = pathstr(pathstr ~= '['); pathstr = pathstr(pathstr ~= ']'); pathstr = strrep(pathstr, ', ',':'); env = ['PYTHONPATH=', pathstr]; % attach optunity's path to env path = mfilename('fullpath'); path = path(1:strfind(path, '/wrappers/matlab/+optunity/+comm/launch')); env = [env, ':', path]; end cmd = 'python -m optunity.piped'; [m2py, py2m, stderr, handle] = optunity.comm.popen( cmd, env ); % provide RAII-style automatic cleanup when cleaner goes out of scope % e.g. both upon normal caller exit or an error cleaner = onCleanup(@()optunity.comm.close_subprocess(m2py, py2m, stderr, ... handle)); endOptunity-0.2.0/wrappers/matlab/+optunity/+comm/json_decode.m0000644000175000017500000000337012356233516023720 0ustar badnbadn00000000000000function [ struct, stop ] = json_decode( json ) %JSON_DECODE Decodes given JSON string. start = 1; if json(start) == '{' [struct, stop] = decode_dict(json(start:end)); elseif json(start) == '[' [struct, stop] = decode_list(json(start:end)); elseif json(start) == '"' % string stop = find(json(start+1:end) == '"', 1) + 1; struct = json(start+1:start+stop-2); else % numeric stop = find(json(start:end) == ',' ... | json(start:end) == '}' ... | json(start:end) == ']', 1)-1; struct = str2double(json(start:start+stop-1)); end stop = stop + start - 1; end function [result, stop] = decode_dict(json) result = struct(); stop = 2; while json(stop) ~= '}' [key, value, stop] = decode_kv(json, stop); result.(key) = value; stop = stop + 1; if json(stop) == ',' stop = stop+2; end end end function [key, value, stop] = decode_kv(json, start) % key is always a string, find its closing " stop = find(json(start+1:end) == '"', 1); key = json(start+1:start+stop-1); stop = start + stop; assert(strcmp(json(stop:stop+2),'": '), 'ILLEGAL JSON FORMAT'); stop = stop+3; % skipping '": ' [value, offset] = optunity.comm.json_decode(json(stop:end)); stop = stop + offset - 1; end function [list, stop] = decode_list(json) stop = 2; use_cell = false; if json(stop) == '"' use_cell = true; elseif json(stop) == '{' use_cell = true; elseif json(stop) == '[' use_cell = true; end list = []; while json(stop) ~= ']' [value, offset] = optunity.comm.json_decode(json(stop:end)); if use_cell list{end+1} = value; else list(end+1) = value; end stop = offset + stop; if json(stop) == ',' stop = stop+2; end end if use_cell list = transpose(list); end endOptunity-0.2.0/wrappers/matlab/+optunity/+comm/popen.m0000644000175000017500000000150412356233516022562 0ustar badnbadn00000000000000function [ stdin, stdout, stderr, p ] = popen( cmd, env ) %POPEN Spawns a subprocess p via Java API and enables bidirectional %communication with its stdin, stdout and stderr. rt = java.lang.Runtime.getRuntime(); if numel(env) > 0 if iscell(env) dim = numel(env); envArr = javaArray('java.lang.String',dim); for ii=1:dim envArr(ii) = java.lang.String(env{ii}); end else envArr = javaArray('java.lang.String',1); envArr(1) = java.lang.String(env); end p = rt.exec(java.lang.String(cmd), envArr); else p = rt.exec(java.lang.String(cmd)); end stderr = java.io.BufferedReader(java.io.InputStreamReader(p.getErrorStream())); stdout = java.io.BufferedReader(java.io.InputStreamReader(p.getInputStream())); stdin = java.io.PrintWriter(p.getOutputStream()); endOptunity-0.2.0/wrappers/matlab/+optunity/+comm/close_subprocess.m0000644000175000017500000000031112356353617025016 0ustar badnbadn00000000000000function close_subprocess( m2py, py2m, stderr, subprocess ) %CLOSE_SUBPROCESS Closes all communication and destroys subprocess. m2py.close(); py2m.close(); stderr.close(); subprocess.destroy(); end Optunity-0.2.0/wrappers/matlab/+optunity/+comm/writepipe.m0000644000175000017500000000025212363273402023444 0ustar badnbadn00000000000000function writepipe( m2py, json ) %WRITEPIPE Sends the json string to the Optunity subprocess over its stdin pipe. m2py.println(java.lang.String(json)); m2py.flush(); end Optunity-0.2.0/wrappers/matlab/+optunity/generate_folds.m0000644000175000017500000000233312356356754023427 0ustar badnbadn00000000000000function folds = generate_folds( n, varargin ) %GENERATE_FOLDS Generates k-fold cross-validation folds. % todo %% process varargin defaults = struct('num_instances', n, ... 'num_folds', 10, ... 'num_iter', 1, ... 'strata', NaN, ... 'clusters', NaN); options = optunity.process_varargin(defaults, varargin); if ~iscell(options.strata) options = rmfield(options, 'strata'); end if ~iscell(options.clusters) options = rmfield(options, 'clusters'); end assert(options.num_instances > options.num_folds, ... 'Number of instances less than number of folds!'); [m2py, py2m, stderr, subprocess, cleaner] = optunity.comm.launch(); init = struct('generate_folds', options); json_request = optunity.comm.json_encode(init); optunity.comm.writepipe(m2py, json_request); json_reply = optunity.comm.readpipe(py2m); reply = optunity.comm.json_decode(json_reply); if isfield(reply, 'error_msg') error(['Error retrieving manual: ',reply.error_msg]); end % Optunity returns 0-based indices, turn into 1-based % turn into a matrix of folds instead of cells niter = numel(reply.folds); folds = zeros(n, niter); for ii=1:niter for jj=1:numel(reply.folds{ii}) folds(1+reply.folds{ii}{jj}, ii) = jj; end end endOptunity-0.2.0/wrappers/matlab/+optunity/process_varargin.m0000644000175000017500000000155112360517620024000 0ustar badnbadn00000000000000function options = process_varargin(defaults, actual_varargin) % inspired by http://stackoverflow.com/a/2776238/2148672 %# read the acceptable names options = defaults; optionNames = fieldnames(options); %# count arguments nArgs = length(actual_varargin); if round(nArgs/2)~=nArgs/2 error('varargin requires propertyName/propertyValue pairs') end for pair = reshape(actual_varargin,2,[]) %# pair is {propName;propValue} inpName = lower(pair{1}); %# make case insensitive if any(strcmp(inpName,optionNames)) %# overwrite options. If you want you can test for the right class here %# Also, if you find out that there is an option you keep getting wrong, %# you can use "if strcmp(inpName,'problemOption'),testMore,end"-statements options.(inpName) = pair{2}; else error('%s is not a recognized parameter name',inpName) end endOptunity-0.2.0/wrappers/matlab/+optunity/manual.m0000644000175000017500000000151012360513067021702 0ustar badnbadn00000000000000function [solver_names] = manual( varargin ) %MANUAL Prints the manual of specified solver or Optunity in general. % % If no solver name is specified, a general manual is printed along with % a list of available solvers. If a name is specified, the same name is % returned. [m2py, py2m, stderr, subprocess, cleaner] = optunity.comm.launch(); if nargin > 0 init = struct('manual',true, 'solver', varargin{1}); else init = struct('manual',true); end json_request = optunity.comm.json_encode(init); optunity.comm.writepipe(m2py, json_request); json_reply = optunity.comm.readpipe(py2m); reply = optunity.comm.json_decode(json_reply); if isfield(reply, 'error_msg') error(['Error retrieving manual: ',reply.error_msg]); end for ii=1:numel(reply.manual) display(reply.manual{ii}); end solver_names = reply.solver_names; endOptunity-0.2.0/wrappers/matlab/+optunity/@Solver/0000755000175000017500000000000012364000746021623 5ustar badnbadn00000000000000Optunity-0.2.0/wrappers/matlab/+optunity/@Solver/Solver.m0000644000175000017500000000252412360517710023256 0ustar badnbadn00000000000000classdef Solver % SOLVER Handle for an Optunity solver. % We recommend constructing Solver objects via optunity.make_solver(). % Please refer to the documentation thereof for further details. % % Solver objects have a maximize(f, varargin) function, offering % equivalent functionality to optunity.maximize(solver, f, varargin). % Please refer to the documentation of optunity.maximize() for details. properties name = ''; config = struct(); end % properties methods function obj = Solver(name, cfg) % Create a Solver object. No sanity checks are performed here. % The recommended approach is using optunity.make_solver(). obj.name = name; obj.config = cfg; end % Solver constructor function [solution, details] = maximize(obj, f, varargin) % Maximizes f using this solver. Equivalent to: % [solution, details] = optunity.maximize(obj, f, varargin); % Please refer to optunity.maximize for more details. [solution, details] = optunity.maximize(obj, f, varargin{:}); end % maximize function result = toStruct(obj) % Returns a struct representation of the Solver. result = struct('solver', obj.name, 'config', obj.config); end % toStruct end % methods end % Solver classOptunity-0.2.0/wrappers/matlab/+optunity/make_solver.m0000644000175000017500000000223112360516110022725 0ustar badnbadn00000000000000function [ solver ] = make_solver( name, varargin ) %MAKE_SOLVER Attempts to construct a solver with given name and options. % This function accepts the following arguments: % - name: name of the solver % - varargin: should be a list of key:value arguments as explained in each % solver's manual. % % Please refer to optunity.manual() for further details on solver options. % An error is generated if construction of the solver fails. %% process varargin assert(mod(numel(varargin), 2) == 0, ... 'varargin should be of the form [key,value,...]'); cfg = struct(varargin{:}); msg = struct('solver', name, 'config', cfg); %% launch SOAP subprocess [m2py, py2m, stderr, subprocess, cleaner] = optunity.comm.launch(); %% attempt to initialize solver json_request = optunity.comm.json_encode(msg); optunity.comm.writepipe(m2py, json_request); json_reply = optunity.comm.readpipe(py2m); reply = optunity.comm.json_decode(json_reply); if isfield(reply, 'error_msg') error(['Error: ', reply.error_msg]); end solver = optunity.Solver(name, cfg); % the optunity subprocess is automatically cleaned up by cleaner % the subprocess is killed and all pipes are closed endOptunity-0.2.0/LICENSE.txt0000644000175000017500000000251012356233516015025 0ustar badnbadn00000000000000Copyright (c) 2014 KU Leuven, ESAT-STADIUS All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither name of copyright holders nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING Optunity-0.2.0/README.rst0000644000175000017500000000312012363556635014677 0ustar badnbadn00000000000000=========== Optunity =========== Optunity is a library containing various optimizers for hyperparameter tuning. Hyperparameter tuning is a recurrent problem in many machine learning tasks, both supervised and unsupervised. Tuning examples include optimizing regularization or kernel parameters. From an optimization point of view, the tuning problem can be considered as follows: the objective function is non-convex, non-differentiable and typically expensive to evaluate. This package provides several distinct approaches to solve such problems including some helpful facilities such as cross-validation and a plethora of score functions. The Optunity library is implemented in Python and allows straightforward integration in other machine learning environments, including R and MATLAB. To get started with Optunity on Linux, issue the following commands:: git clone https://github.com/claesenm/optunity.git echo "export PYTHONPATH=$PYTHONPATH:$(pwd)/optunity" >> ~/.bashrc Afterwards, importing ``optunity`` should work in Python:: #!/usr/bin/env python import optunity Optunity is developed at the STADIUS lab of the dept. of electrical engineering at KU Leuven (ESAT). Optunity is free software, using a BSD license. For more information, please refer to the following pages: http://optunity.readthedocs.org/en/latest/ Contributors ============ The main contributors to Optunity are: * Marc Claesen: framework design & implementation, communication infrastructure, MATLAB wrapper and a variety of solvers. * Jaak Simm: R wrapper. * Dusan Popovic: genetic algorithm solver. Optunity-0.2.0/requirements.txt0000644000175000017500000000007312361256303016463 0ustar badnbadn00000000000000Optunity==0.2.0 argparse==1.2.1 deap==1.0.1 wsgiref==0.1.2 Optunity-0.2.0/docs/0000755000175000017500000000000012364000746014130 5ustar badnbadn00000000000000Optunity-0.2.0/docs/_build/0000755000175000017500000000000012364000746015366 5ustar badnbadn00000000000000Optunity-0.2.0/docs/_build/html/0000755000175000017500000000000012364000746016332 5ustar badnbadn00000000000000Optunity-0.2.0/docs/_build/html/_sources/0000755000175000017500000000000012364000746020154 5ustar badnbadn00000000000000Optunity-0.2.0/docs/_build/html/_sources/dev/0000755000175000017500000000000012364000746020732 5ustar badnbadn00000000000000Optunity-0.2.0/docs/_build/html/_sources/dev/index.txt0000644000175000017500000000006012361252064022575 0ustar badnbadn00000000000000=============== Developer Guide =============== Optunity-0.2.0/docs/_build/html/_sources/examples/0000755000175000017500000000000012364000746021772 5ustar badnbadn00000000000000Optunity-0.2.0/docs/_build/html/_sources/examples/cross_validation.txt0000644000175000017500000000751712361742072026112 0ustar badnbadn00000000000000========================== Cross-validation Examples ========================== Optunity offers a simply interface to k-fold cross-validation_. .. _cross-validation: http://en.wikipedia.org/wiki/Cross-validation_(statistics) The fold generation procedure is aware of both strata and clusters. Please refer to :doc:`/user/cross_validation` for an overview and :func:`optunity.cross_validated` for implementation and API details. We will build examples step by step. The basic setup is a ``train`` and ``predict`` function along with some ``data`` to construct folds over:: from __future__ import print_function import optunity as opt def train(x, y, filler=''): print(filler + 'Training data:') for instance, label in zip(x, y): print(filler + str(instance) + ' ' + str(label)) def predict(x, filler=''): print(filler + 'Testing data:') for instance in x: print(filler + str(instance)) data = list(range(9)) labels = [0] * 9 The recommended way to perform cross-validation is using the :func:`optunity.cross_validation.cross_validated` function decorator:: @opt.cross_validated(x=data, y=labels, num_folds=3) def cved(x_train, y_train, x_test, y_test): train(x_train, y_train) predict(x_test) return 0.0 cved() Nested cross-validation -------------------------- Nested cross-validation is a commonly used approach to estimate the generalization performance of a modeling process which includes model selection internally. A good summary is provided here_. .. _here: http://stats.stackexchange.com/a/65156/25433 Nested cv consists of two cross-validation procedures wrapped around eachother. The inner cv is used for model selection, the outer cv estimates generalization performance. This can be done in a straightforward manner using Optunity:: @opt.cross_validated(x=data, y=labels, num_folds=3) def nested_cv(x_train, y_train, x_test, y_test): @opt.cross_validated(x=x_train, y=y_train, num_folds=3) def inner_cv(x_train, y_train, x_test, y_test): train(x_train, y_train, '...') predict(x_test, '...') return 0.0 inner_cv() predict(x_test) return 0.0 nested_cv() The inner :func:`optunity.cross_validated` decorator has access to the train and test folds generated by the outer procedure (``x_train`` and ``x_test``). For notational simplicity we assume a problem without labels here. .. note:: The inner folds are regenerated in every iteration (since we are redefining ``inner_cv`` each time). The inner folds will therefore be different each time. The outer folds remain static, unless ``regenerate_folds=True`` is passed. Below we illustrate a more complete example of nested cv, which includes hyperparameter optimization with :func:`optunity.maximize`. Assume we have access to the following functions ``svm=svm_train(x, y, c, g)`` and ``predictions=svm_predict(svm, x)``. Where ``c`` and ``g`` are hyperparameters to be optimized for accuracy:: @opt.cross_validated(x=data, num_folds=3) def nested_cv(x_train, y_train, x_test, y_test): @opt.cross_validated(x=x_train, y=y_train, num_folds=3) def inner_cv(x_train, y_train, x_test, y_test, c, g): svm = svm_train(x_train, y_train, c, g) predictions = svm_predict(svm, x_test) return opt.score_functions.accuracy(y_test, predictions) optimal_parameters = opt.maximize(inner_cv, num_evals=100, c=[0, 10], g=[0, 10]) optimal_svm = svm_train(x_train, y_train, **optimal_parameters) predictions = svm_predict(optimal_svm, x_test) return opt.score_functions.accuracy(y_test, predictions) overall_accuracy = nested_cv() .. note:: You are free to use different score and aggregation functions in the inner and outer cv. Optunity-0.2.0/docs/_build/html/_sources/examples/index.txt0000644000175000017500000000016612361664163023653 0ustar badnbadn00000000000000=========== Examples =========== .. toctree:: :maxdepth: 2 :includehidden: /examples/cross_validation Optunity-0.2.0/docs/_build/html/_sources/index.txt0000644000175000017500000000515712361321127022030 0ustar badnbadn00000000000000=========== Optunity =========== Optunity is a library containing various optimizers for hyperparameter tuning. Hyperparameter tuning is a recurrent problem in many machine learning tasks, both supervised and unsupervised.This package provides several distinct approaches to solve such problems including some helpful facilities such as cross-validation and a plethora of score functions. .. sidebar:: **Getting started** * :doc:`Overview ` * :doc:`Installation ` * `Report a problem `_ From an optimization point of view, the tuning problem can be considered as follows: the objective function is non-convex, non-smooth and typically expensive to evaluate. Tuning examples include optimizing regularization or kernel parameters. The Optunity library is implemented in Python and allows straightforward integration in other machine learning environments, including :doc:`R ` and :doc:`MATLAB `. Optunity is free software, using a BSD-style license. User Guide ============== **Quick setup** Issue the following commands to get started on Linux: .. code-block:: bash git clone https://github.com/claesenm/optunity.git export PYTHONPATH=#PYTHONPATH:$(pwd)/optunity/ Afterwards, importing ``optunity`` should work in Python: .. code-block:: bash python -c 'import optunity' For a proper installation, run the following: .. code-block:: bash python optunity/setup.py install Installation may require superuser priviliges. ------------- **Examples of Optunity usage** * :doc:`Optimizing a simple function ` * :doc:`Tuning SVM hyperparameters ` For more examples, please see our :doc:`examples page `. Developer Guide ================= - :doc:`Developer guide ` - :doc:`API reference ` Contributors ============ Optunity is developed at the STADIUS lab of the dept. of electrical engineering at KU Leuven (ESAT). The main contributors to Optunity are: **Marc Claesen** - Python package - framework design & implementation - solver implementation - communication protocol design & implementation - MATLAB wrapper **Jaak Simm** - communication protocol design - R wrapper **Dusan Popovic** - code examples Indices and tables ================== * :ref:`genindex` * :ref:`modindex` * :ref:`search` .. toctree:: :maxdepth: 2 :includehidden: /user/installation /user/index /examples/index /wrappers/index /dev/index /api/optunity Optunity-0.2.0/docs/_build/html/_sources/wrappers/0000755000175000017500000000000012364000746022017 5ustar badnbadn00000000000000Optunity-0.2.0/docs/_build/html/_sources/wrappers/R/0000755000175000017500000000000012364000746022220 5ustar badnbadn00000000000000Optunity-0.2.0/docs/_build/html/_sources/wrappers/R/installation.txt0000644000175000017500000000011012361276633025461 0ustar badnbadn00000000000000======================== Installing in R ======================== TODO Optunity-0.2.0/docs/_build/html/_sources/wrappers/R/index.txt0000644000175000017500000000003512361236216024066 0ustar badnbadn00000000000000=========== TODO =========== Optunity-0.2.0/docs/_build/html/_sources/wrappers/matlab/0000755000175000017500000000000012364000746023257 5ustar badnbadn00000000000000Optunity-0.2.0/docs/_build/html/_sources/wrappers/matlab/installation.txt0000644000175000017500000000013412361276533026525 0ustar badnbadn00000000000000============================== Installation for MATLAB ============================== TODO Optunity-0.2.0/docs/_build/html/_sources/wrappers/matlab/index.txt0000644000175000017500000000003512361236214025123 0ustar badnbadn00000000000000=========== TODO =========== Optunity-0.2.0/docs/_build/html/_sources/wrappers/index.txt0000644000175000017500000000023612361300422023657 0ustar badnbadn00000000000000========================= Using Other Environments ========================= .. toctree:: :maxdepth: 2 /wrappers/matlab/index /wrappers/R/index Optunity-0.2.0/docs/_build/html/_sources/optunity.test.txt0000644000175000017500000000077112361164307023574 0ustar badnbadn00000000000000optunity.test package ===================== Submodules ---------- optunity.test.functions module ------------------------------ .. automodule:: optunity.test.functions :members: :undoc-members: :show-inheritance: optunity.test.solvers module ---------------------------- .. automodule:: optunity.test.solvers :members: :undoc-members: :show-inheritance: Module contents --------------- .. automodule:: optunity.test :members: :undoc-members: :show-inheritance: Optunity-0.2.0/docs/_build/html/_sources/user/0000755000175000017500000000000012364000746021132 5ustar badnbadn00000000000000Optunity-0.2.0/docs/_build/html/_sources/user/solvers.txt0000644000175000017500000000025712361301037023366 0ustar badnbadn00000000000000=================== Solver Overview =================== .. toctree:: :maxdepth: 2 :glob: /user/solvers/* This page contains a high-level overview of Optunity. Optunity-0.2.0/docs/_build/html/_sources/user/installation.txt0000644000175000017500000000237512361305537024406 0ustar badnbadn00000000000000==================== Installing Optunity ==================== .. toctree:: :hidden: /wrappers/matlab/installation /wrappers/R/installation Optunity can be installed as a typical Python package. .. note:: Optunity has soft dependencies on NumPy_ and SciPy_ (for the :doc:`CMA-ES ` and :doc:`Nelder-Mead ` solvers, respectively). If these dependencies are not met, the associated solvers are unavailable. Optunity additionally ships with DEAP, a library for evolutionary algorithms [DEAP2012]_, which is used to implement the :doc:`/user/solvers/particle_swarm` and the :doc:`/user/solvers/CMA_ES`. .. [DEAP2012] Fortin, FĂ©lix-Antoine, et al. "DEAP: Evolutionary algorithms made easy." Journal of Machine Learning Research 13.1 (2012): 2171-2175. .. _NumPy: http://www.numpy.org .. _SciPy: http://www.scipy.org Setting up Optunity for other environments =========================================== If you want to use Optunity in a non-Python environment, please refer to the environment-specific installation instructions. - :doc:`MATLAB installation <../wrappers/matlab/installation>` - :doc:`R installation <../wrappers/R/installation>` Optunity-0.2.0/docs/_build/html/_sources/user/cross_validation.txt0000644000175000017500000000021412361246614025236 0ustar badnbadn00000000000000=================== Cross-validation =================== .. toctree:: :hidden: This page contains a high-level overview of Optunity. Optunity-0.2.0/docs/_build/html/_sources/user/index.txt0000644000175000017500000000035512361300155022777 0ustar badnbadn00000000000000=================== Optunity User Guide =================== .. toctree:: :maxdepth: 2 /user/installation /user/solvers /user/cross_validation /user/functions This page contains a high-level overview of Optunity. Optunity-0.2.0/docs/_build/html/_sources/user/solvers/0000755000175000017500000000000012364000746022627 5ustar badnbadn00000000000000Optunity-0.2.0/docs/_build/html/_sources/user/solvers/CMA_ES.txt0000644000175000017500000000005612361277555024373 0ustar badnbadn00000000000000=============== CMA-ES solver =============== Optunity-0.2.0/docs/_build/html/_sources/user/solvers/particle_swarm.txt0000644000175000017500000000010512361300026026367 0ustar badnbadn00000000000000====================== Particle Swarm Solver ====================== Optunity-0.2.0/docs/_build/html/_sources/user/solvers/random_search.txt0000644000175000017500000000010112361277646026201 0ustar badnbadn00000000000000===================== Random Search Solver ===================== Optunity-0.2.0/docs/_build/html/_sources/user/solvers/nelder-mead.txt0000644000175000017500000000007412361277675025564 0ustar badnbadn00000000000000=================== Nelder-Mead Solver =================== Optunity-0.2.0/docs/_build/html/_sources/user/solvers/grid_search.txt0000644000175000017500000000007412361277621025650 0ustar badnbadn00000000000000=================== Grid Search Solver =================== Optunity-0.2.0/docs/_build/html/_sources/user/functions.txt0000644000175000017500000000022012361246632023700 0ustar badnbadn00000000000000=================== Function Decorators =================== .. toctree:: :hidden: This page contains a high-level overview of Optunity. Optunity-0.2.0/docs/_build/html/_sources/user/overview.txt0000644000175000017500000000016312361233165023541 0ustar badnbadn00000000000000=================== Optunity overview =================== This page contains a high-level overview of Optunity. Optunity-0.2.0/docs/_build/html/_sources/api/0000755000175000017500000000000012364000746020725 5ustar badnbadn00000000000000Optunity-0.2.0/docs/_build/html/_sources/api/optunity.score_functions.txt0000644000175000017500000000023412361321746026565 0ustar badnbadn00000000000000optunity.score_functions =============================== .. automodule:: optunity.score_functions :members: :undoc-members: :show-inheritance: Optunity-0.2.0/docs/_build/html/_sources/api/optunity.example.txt0000644000175000017500000000021312361247756025022 0ustar badnbadn00000000000000optunity.example module ======================= .. automodule:: optunity.example :members: :undoc-members: :show-inheritance: Optunity-0.2.0/docs/_build/html/_sources/api/modules.txt0000644000175000017500000000007512361247756023153 0ustar badnbadn00000000000000Optunity ======== .. toctree:: :maxdepth: 4 optunity Optunity-0.2.0/docs/_build/html/_sources/api/optunity.test.functions.txt0000644000175000017500000000024012361247756026355 0ustar badnbadn00000000000000optunity.test.functions module ============================== .. automodule:: optunity.test.functions :members: :undoc-members: :show-inheritance: Optunity-0.2.0/docs/_build/html/_sources/api/optunity.test.solvers.txt0000644000175000017500000000023212361247756026043 0ustar badnbadn00000000000000optunity.test.solvers module ============================ .. automodule:: optunity.test.solvers :members: :undoc-members: :show-inheritance: Optunity-0.2.0/docs/_build/html/_sources/api/optunity.communication.txt0000644000175000017500000000022612361321774026231 0ustar badnbadn00000000000000optunity.communication ============================= .. automodule:: optunity.communication :members: :undoc-members: :show-inheritance: Optunity-0.2.0/docs/_build/html/_sources/api/optunity.solvers.txt0000644000175000017500000000020412361321721025045 0ustar badnbadn00000000000000optunity.solvers ======================= .. automodule:: optunity.solvers :members: :undoc-members: :show-inheritance: Optunity-0.2.0/docs/_build/html/_sources/api/optunity.cross_validation.txt0000644000175000017500000000023412361321736026724 0ustar badnbadn00000000000000optunity.cross_validation ============================= .. automodule:: optunity.cross_validation :members: :undoc-members: :show-inheritance: Optunity-0.2.0/docs/_build/html/_sources/api/optunity.test.txt0000644000175000017500000000037712361247756024361 0ustar badnbadn00000000000000optunity.test package ===================== Submodules ---------- .. toctree:: optunity.test.functions optunity.test.solvers Module contents --------------- .. automodule:: optunity.test :members: :undoc-members: :show-inheritance: Optunity-0.2.0/docs/_build/html/_sources/api/optunity.util.txt0000644000175000017500000000017312361322021024324 0ustar badnbadn00000000000000optunity.util ==================== .. automodule:: optunity.util :members: :undoc-members: :show-inheritance: Optunity-0.2.0/docs/_build/html/_sources/api/optunity.solver_registry.txt0000644000175000017500000000023412361322013026610 0ustar badnbadn00000000000000optunity.solver_registry =============================== .. automodule:: optunity.solver_registry :members: :undoc-members: :show-inheritance: Optunity-0.2.0/docs/_build/html/_sources/api/optunity.txt0000644000175000017500000000112212361422536023357 0ustar badnbadn00000000000000================ Optunity API ================ Module contents --------------- .. sidebar:: optunity submodules **Key submodules** .. toctree:: optunity.solvers optunity.cross_validation optunity.score_functions optunity.functions **Other submodules** .. toctree:: optunity.api optunity.communication optunity.piped optunity.solver_registry optunity.util .. automodule:: optunity :members: :undoc-members: :show-inheritance: Subpackages ----------- .. toctree:: optunity.test Optunity-0.2.0/docs/_build/html/_sources/api/optunity.functions.txt0000644000175000017500000000021212361321756025367 0ustar badnbadn00000000000000optunity.functions ========================= .. automodule:: optunity.functions :members: :undoc-members: :show-inheritance: Optunity-0.2.0/docs/_build/html/_sources/api/optunity.api.txt0000644000175000017500000000017012361321765024133 0ustar badnbadn00000000000000optunity.api =================== .. automodule:: optunity.api :members: :undoc-members: :show-inheritance: Optunity-0.2.0/docs/_build/html/_sources/api/optunity.piped.txt0000644000175000017500000000017612361322003024453 0ustar badnbadn00000000000000optunity.piped ===================== .. automodule:: optunity.piped :members: :undoc-members: :show-inheritance: Optunity-0.2.0/docs/_build/html/_sources/optunity.txt0000644000175000017500000000324612361221431022606 0ustar badnbadn00000000000000optunity package ================ Subpackages ----------- .. toctree:: optunity.test Submodules ---------- optunity.api module ------------------- .. automodule:: optunity.api :members: :undoc-members: :show-inheritance: optunity.communication module ----------------------------- .. automodule:: optunity.communication :members: :undoc-members: :show-inheritance: optunity.cross_validation module -------------------------------- .. automodule:: optunity.cross_validation :members: :undoc-members: :show-inheritance: optunity.example module ----------------------- .. automodule:: optunity.example :members: :undoc-members: :show-inheritance: optunity.functions module ------------------------- .. automodule:: optunity.functions :members: :undoc-members: :show-inheritance: optunity.piped module --------------------- .. automodule:: optunity.piped :members: :undoc-members: :show-inheritance: optunity.score_functions module ------------------------------- .. automodule:: optunity.score_functions :members: :undoc-members: :show-inheritance: optunity.solver_registry module ------------------------------- .. automodule:: optunity.solver_registry :members: :undoc-members: :show-inheritance: optunity.solvers module ----------------------- .. automodule:: optunity.solvers :members: :undoc-members: :show-inheritance: optunity.util module -------------------- .. automodule:: optunity.util :members: :undoc-members: :show-inheritance: Module contents --------------- .. automodule:: optunity :members: :undoc-members: :show-inheritance: Optunity-0.2.0/setup.py0000644000175000017500000000072312364000632014706 0ustar badnbadn00000000000000from distutils.core import setup setup( name='Optunity', version='0.2.0', author='Marc Claesen', author_email='marc.claesen@esat.kuleuven.be', packages=['optunity', 'optunity.test'], scripts=[], url='http://optunity.readthedocs.org', license='LICENSE.txt', description='Optimization routines for hyperparameter tuning.', long_description=open('README.rst').read(), install_requires=[ 'deap >= 1.0.1', ], )