from febo.algorithms import Algorithm, AlgorithmConfig, ModelMixin
from febo.utils import get_logger, locate
from febo.utils.config import assign_config, ConfigField
from febo.solvers import GridSolver, CandidateSolver, FiniteDomainSolver
import numpy as np
import os
import matplotlib.pyplot as plt
from febo.algorithms.subdomainbo.utils import maximize, dimension_setting_helper
from .utils import plot_parameter_changes, plot_model_changes
from .subdomain import LineDomain, TrustRegionDomain
from scipy.spatial.distance import pdist
logger = get_logger('algorithm')
class SubDomainBOConfig(AlgorithmConfig):
points_in_max_interval_to_stop = ConfigField(10)
min_queries_line = ConfigField(10)
max_queries_line = ConfigField(30)
min_queries_tr = ConfigField('d')
max_queries_tr = ConfigField('2*d')
tr_radius = ConfigField(0.1)
tr_method = ConfigField('grad')
line_boundary_margin = ConfigField(0.1)
plot = ConfigField(False)
plot_every_step = ConfigField(False)
acquisition = ConfigField('febo.algorithms.subdomainbo.acquisition.ts')
_section = 'algorithm.subdomainbo'
from febo.environment import ContinuousDomain
from febo.utils import get_logger
from febo.utils.config import assign_config, ConfigField, Configurable, Config, config_manager
from febo.environment.domain import DiscreteDomain
import numpy as np
logger = get_logger('environment')
class NoiseConfig(Config):
low = ConfigField(0.5, comment="May be used by the noise function to roughly set the lowest noise level.")
high = ConfigField(0.5, comment="May be used by the noise function to roughly set the higest noise level.")
seed = ConfigField(None, comment="Seed for randomly generated noise function.", allow_none=True)
_section = 'environment.benchmark.noise'
# config_manager.register(NoiseConfig)
@assign_config(NoiseConfig)
class NoiseFunction(Configurable):
"""
Base class to implement custom noise functions.
Note that the configuration of BenchmarkEnvironment.noise_function also takes an ordinary python function.
Args:
x: evaluation point
Returns:
Variance at x
"""
def __init__(self, domain, benchmark_f=None):
self._domain = domain
import sys
# sys.path.append("/Users/davidal/GoogleDrive/BachelorThesis/bacode/tripathy")
sys.path.append("/cluster/home/yedavid/BachelorThesis/tripathy/")
sys.path.append("/Users/davidal/GoogleDrive/BachelorThesis/bacode")
from febo.models import ConfidenceBoundModel
from febo.models.model import ModelConfig
from febo.models.gpy import GPRegression
from febo.utils.config import ConfigField, assign_config, config_manager
import GPy
from scipy.linalg import lapack
from scipy.optimize import minimize
logger = get_logger('model')
class TripathyGPConfig(ModelConfig):
"""
* kernels: List of kernels
* noise_var: noise variance
"""
# kernels = ConfigField([('GPy.kern.RBF', {'variance': 2., 'lengthscale': 0.2 , 'ARD': True})])
noise_var = ConfigField(0.01)
calculate_gradients = ConfigField(False, comment='Enable/Disable computation of gradient on each update.')
optimize_bias = ConfigField(False)
optimize_var = ConfigField(False)
bias = ConfigField(0)
_section = 'src.tripathy__'
import h5py
from febo.utils.config import Configurable, Config, ConfigField, assign_config
import os
from febo.utils import get_logger
import numpy as np
logger = get_logger("controller")
class DataBaseConfig(Config):
chunk_size = ConfigField(200)
_section = 'database'
@assign_config(DataBaseConfig)
class DataSet(Configurable):
"""
Thin wrapper around a hdf5 table to store evaluations.
"""
def __init__(self, group, id=None, dtype=None):
""" read table `id` from group, or creates a table with name `id` if not existing. """
if id is None:
id = len(group)
id = str(id)
if not id in group:
if dtype is None:
raise Exception("dtype not provided and table does not exist.")
# sys.path.append("/cluster/home/yedavid/BachelorThesis/tripathy/")
# sys.path.append("/Users/davidal/GoogleDrive/BachelorThesis/bacode")
from febo.models import ConfidenceBoundModel
from febo.models.model import ModelConfig
from febo.models.gpy import GPRegression
from febo.utils.config import ConfigField, assign_config, config_manager
import GPy
from scipy.linalg import lapack
from scipy.optimize import minimize
from bacode.tripathy.src.bilionis_refactor.config import config
from bacode.tripathy.src.bilionis_refactor.t_optimization_functions import t_ParameterOptimizer
from bacode.tripathy.src.boring.generate_orthogonal_basis import generate_orthogonal_matrix_to_A
logger = get_logger('tripathy')
from febo.utils import locate, get_logger
import gc
class BoringGPConfig(ModelConfig):
"""
* kernels: List of kernels
* noise_var: noise variance
"""
# kernels = ConfigField([('GPy.kern.Matern32', {'variance': 1., 'lengthscale': 1.5, 'ARD': True})])
noise_var = ConfigField(0.01)
calculate_gradients = ConfigField(
False,
import inspect
from enum import Enum
from io import StringIO
from ruamel.yaml import YAML
from ruamel.yaml.comments import CommentedMap
from febo.utils import locate, get_logger
logger = get_logger('config')
class ConfigManager:
""" class to track all instances of Config classes, and load and save configs to yaml. """
def __init__(self):
self._configs = [] # list of all configs
self._config_classes = [] # list of all config classes
self._configurable_classes = [] # list of all config classes
self._fields = {} # dictionary of all fields
self._fields_origin = {
} # dictionary to keep track what class fields come from
self._data = {} # dict for current data
self._locked = False
self._autoregister = False
def reset(self):
for key in self._data.keys():
self._data[key] = {}
def set_autoregister(self, autoregister):
self._autoregister = autoregister
import os
from febo import utils
from febo.experiment.data import DataBase
from febo.utils import get_timestamp, get_logger
from febo.utils.config import Config, ConfigField, config_manager, assign_config, Configurable
try:
import ceramo
except ImportError:
pass
logger = get_logger("experiment")
class ExperimentConfig(Config):
_section = 'experiment'
@assign_config(ExperimentConfig)
class Experiment(Configurable):
def __init__(self, experiment_dir):
self._directory = None
self._timestamp = None
self._dbase = None
self._experiment_dir = experiment_dir
@property
def directory(self):
return self._directory
@property
def timestamp(self):
return self._timestamp
import numpy as np
from febo.environment import ContinuousDomain
from febo.utils import locate
from febo.environment.domain import DiscreteDomain
# from models.model import ScaleShiftModel
from febo.utils import get_logger
from febo.utils.config import ConfigField, Config, Configurable, assign_config, config_manager, ClassConfigField
import time
logger = get_logger("algorithm")
class AlgorithmConfig(Config):
_section = 'algorithm'
# config_manager.register(AlgorithmConfig)
@assign_config(AlgorithmConfig)
class Algorithm(Configurable):
"""
Base class for algorithms.
"""
def __init__(self, **experiment_info):
self.experiment_info = experiment_info
self._dtype_fields = []
self.name = type(self).__name__
import matplotlib.pyplot as plt
import numpy as np
from febo.utils import get_logger
from febo.utils.config import Config, ConfigField, assign_config, ClassConfigField
import scipy.stats as stats
import os
logger = get_logger("plotting")
class Plot:
def __init__(self, experiment):
self.experiment = experiment
self._title = None
self._show_legend = False
@property
def title(self):
return self._title
def plot(self, show=True, group_id=None, run_id=None):
from febo.experiment import MultiExperiment, SimpleExperiment
from febo.controller import SequentialController, RepetitionController
path_subdir = "" # is set to group_id if group_id != None
run_id_str = None # either "-all" if run_id == None, als "-{run_id}"
# plot data from simple experiment, or a single data group
if type(self.experiment) is SimpleExperiment or group_id != None:
if group_id != None:
class ScipySolverConfig(Config):
lbfgs_use_gradients = ConfigField(False)
lbfgs_maxfun = ConfigField(1000)
# lbfgs_maxiter = ConfigField(1000)
num_restart = ConfigField(50)
num_processes = ConfigField(1)
sync_restarts = ConfigField(True)
convergence_warnings = ConfigField(True)
_section = 'solver.scipy'
# config_manager.register(ScipyOptimizerConfig)
logger = get_logger('solver.scipy')
class FunWrapper:
def __init__(self,
fun,
use_gradients,
safe_mode=False,
safety_wrapper=None):
self._fun = fun
self.best_x = None
self.best_y = 10e10
self._use_gradients = use_gradients
self._safe_mode = safe_mode
self._safety_wrapper = safety_wrapper
celery_app = Celery('tasks')
celery_app.config_from_object(ceramo.celeryconfig)
except ImportError:
pass
# if subdirectory is in path, remove it there, because this causes trouble with relative imports
current_dir = os.path.abspath(os.path.dirname(__file__))
if current_dir in sys.path:
sys.path.pop(sys.path.index(current_dir))
# also remove relatives path which are added by the profiler
if 'febo' in sys.path:
sys.path.pop(sys.path.index('febo'))
logger = get_logger('main')
class MainConfig(Config):
experiment = ClassConfigField('febo.experiment.SimpleExperiment', comment="Experiment")
modules = ConfigField([])
log_level_console = ConfigField('INFO')
log_level_file = ConfigField('INFO')
experiment_dir = ConfigField('runs/')
sync_dir = ConfigField('remote/')
plotting_backend = ConfigField(None, allow_none=True, comment='Set to "agg" on machines where default matplotlib qt backend is not available.')
_section = 'main'
main_config = MainConfig()
from febo.plots import Plot
from febo.utils import get_logger
from febo.utils.config import config_manager
import numpy as np
import matplotlib.pyplot as plt
import scipy
import os
logger = get_logger('plots')
class Beta(Plot):
def plot(self, show=True, group_id=None, run_id=None):
hdf5 = self.experiment.hdf5
performance = {}
T = config_manager.get_setting('controller', 'T')
logger.info(f'Reading values at time T={T}')
# if isinstance(self.experiment, MultiExperiment):
for item in self.experiment.parts:
dset_group = hdf5[str(item.id)]
algorithm = dset_group.attrs['algorithm']
# if 'algorithm.bose' in item.config:
# algorithm += f"-{item.config['algorithm.bose'].get('compute_method', '')}"
# if 'algorithm.ids' in item.config:
# algorithm += f"-{item.config['algorithm.ids'].get('compute_method', '')}"
# algorithm += f"-{item.config['algorithm.ids'].get('use_1pa', '')}"
# initialize
if not algorithm in performance:
sys.path.append("/Users/davidal/GoogleDrive/BachelorThesis/bacode")
from febo.models import ConfidenceBoundModel
from febo.models.model import ModelConfig
from febo.models.gpy import GPRegression
from febo.utils.config import ConfigField, assign_config, config_manager
import GPy
from scipy.linalg import lapack
from scipy.optimize import minimize
from GPy.kern.src.rbf import RBF
from GPy.kern import Matern32
# from GPy.kern.src.sde_matern import Matern32
logger = get_logger('boring')
class BoringModelConfig(ModelConfig):
"""
* kernels: List of kernels
* noise_var: noise variance
"""
# kernels = ConfigField([('GPy.kern.RBF', {'variance': 2., 'lengthscale': 0.2 , 'ARD': True})])
noise_var = ConfigField(0.01)
calculate_gradients = ConfigField(
False,
comment='Enable/Disable computation of gradient on each update.')
optimize_bias = ConfigField(False)
optimize_var = ConfigField(False)
import numpy as np
from functools import wraps
from enum import Enum
from febo.utils import get_logger
from febo.utils.config import ConfigField, Config, Configurable, assign_config, config_manager
class EnvironmentConfig(Config):
_section = 'environment'
# config_manager.register(EnvironmentConfig)
logger = get_logger("environment")
@assign_config(EnvironmentConfig)
class Environment(Configurable):
def __init__(self, path=None):
self._domain = None
self._tmax = None
self._path = path
@property
def name(self):
return f"{type(self).__module__}.{type(self).__name__}"
@property
def domain(self):
return self._domain
