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