Exemple #1
0
    def calc_scales(self):
        """
        calculate scales for normalized simplex

        :return: np.array() - device_delta_limits * norm_coef
        """
        self.norm_scales = normscales.normscales(
            self.target.mi, self.devices)[0]  # 0th element is length scales

        for idx, dev in enumerate(self.devices):
            if self.norm_scales[idx] is not None:
                continue
            delta = dev.get_delta()
            self.norm_scales[idx] = delta * self.norm_coef

        self.norm_scales = np.array(self.norm_scales)

        # Randomize the initial steps of simplex - Talk to Joe if it fails
        if isinstance(self.minimizer, Simplex):
            self.norm_scales *= np.sign(np.random.randn(self.norm_scales.size))
        return self.norm_scales
Exemple #2
0
    def preprocess(self):
        self.target.mi.target = self.target

        # assemble hyper parameters
        self.length_scales, self.amp_variance, self.single_noise_variance, self.mean_noise_variance, self.precision_matrix = normscales.normscales(
            self.target.mi, self.devices, correlationsQ=self.correlationsQ)

        # build precision_matrix if not returned
        print('Precision before', self.precision_matrix)
        if self.precision_matrix is None:
            self.covarmat = np.diag(self.length_scales)**2
            print('Covariance', self.covarmat)
            self.precision_matrix = np.linalg.inv(self.covarmat)
        print('Precision', self.precision_matrix)
        print('Length Scales', self.length_scales)
        # create OnlineGP model
        dim = len(self.devices)
        hyperparams = (self.precision_matrix, np.log(self.amp_variance),
                       np.log(self.mean_noise_variance))
        #        self.model = OGP(dim, hyperparams, maxBV=self.numBV, weighted=False)
        self.model = OGP(dim,
                         hyperparams,
                         maxBV=self.numBV,
                         covar=['RBF_ARD', 'MATERN32_ARD', 'MATERN52_ARD'][0],
                         weighted=False)
        # initialize model on prior data if available
        if (self.prior_data is not None):
            p_X = self.prior_data.iloc[:, :-1]
            p_Y = self.prior_data.iloc[:, -1]
            num = p_X.shape[0]
            self.model.fit(p_X, p_Y, min(self.m, num))

        # create Bayesian optimizer
        dev_ids = [dev.eid for dev in self.devices]
        dev_vals = [dev.get_value() for dev in self.devices]
        self.scanner = BayesOpt(
            model=self.model,
            target_func=self.target,
            acq_func=self.acq_func,
            xi=self.xi,
            alt_param=self.alt_param,
            m=self.m,
            bounds=self.bounds,
            iter_bound=self.iter_bound,
            prior_data=self.prior_data,
            start_dev_vals=dev_vals,
            dev_ids=dev_ids,
            searchBoundScaleFactor=self.searchBoundScaleFactor)
        self.scanner.max_iter = self.max_iter
        self.scanner.opt_ctrl = self.opt_ctrl