def train_gp(self): """Optimizes the hyperparameters of the current GP model.""" self.gp.train(logger_name=self.output.basename+'hyps') hyps, labels = Parameters.get_hyps( self.gp.hyps_mask, self.gp.hyps, constraint=False, label=True) if labels is None: labels = self.gp.hyp_labels self.output.write_hyps(labels, hyps, self.start_time, self.gp.likelihood, self.gp.likelihood_gradient, hyps_mask=self.gp.hyps_mask)
def train_gp(self, max_iter: int = None): """ Train the Gaussian process and write the results to the output file. :param max_iter: Maximum iterations associated with this training run, overriding the Gaussian Process's internally set maxiter. :type max_iter: int """ logger = logging.getLogger(self.logger_name) if self.gp_is_mapped: logger.debug("Training skipped because of MGP") return logger.debug("Train GP") logger_train = self.output.basename + "hyps" # TODO: Improve flexibility in GP training to make this next step # unnecessary, so maxiter can be passed as an argument # Don't train if maxiter == 0 if max_iter == 0: self.gp.check_L_alpha() elif max_iter is not None: temp_maxiter = self.gp.maxiter self.gp.maxiter = max_iter self.gp.train(logger_name=logger_train) self.gp.maxiter = temp_maxiter else: self.gp.train(logger_name=logger_train) hyps, labels = Parameters.get_hyps(self.gp.hyps_mask, self.gp.hyps, constraint=False, label=True) if labels is None: labels = self.gp.hyp_labels self.output.write_hyps( labels, hyps, self.start_time, self.gp.likelihood, self.gp.likelihood_gradient, hyps_mask=self.gp.hyps_mask, ) self.train_count += 1
def test_hyps_grad(kernels, diff_cutoff, constraint): delta = 1e-8 d1 = 1 d2 = 2 tol = 1e-4 np.random.seed(10) cutoffs, hyps, hm = generate_diff_hm(kernels, diff_cutoff, constraint=constraint) args = from_mask_to_args(hyps, cutoffs, hm) kernel, kernel_grad, _, _, _, _, _ = str_to_kernel_set(kernels, "mc", hm) np.random.seed(0) env1 = generate_mb_envs(cutoffs, np.eye(3) * 100, delta, d1) env2 = generate_mb_envs(cutoffs, np.eye(3) * 100, delta, d2) env1 = env1[0][0] env2 = env2[0][0] k, grad = kernel_grad(env1, env2, d1, d2, *args) original = kernel(env1, env2, d1, d2, *args) nhyps = len(hyps) if hm['train_noise']: nhyps -= 1 original_hyps = Parameters.get_hyps(hm, hyps=hyps) for i in range(nhyps): newhyps = np.copy(hyps) newhyps[i] += delta if ('map' in hm.keys()): newid = hm['map'][i] hm['original_hyps'] = np.copy(original_hyps) hm['original_hyps'][newid] += delta newargs = from_mask_to_args(newhyps, cutoffs, hm) hgrad = (kernel(env1, env2, d1, d2, *newargs) - original) / delta if 'map' in hm: print(i, "hgrad", hgrad, grad[hm['map'][i]]) assert (isclose(grad[hm['map'][i]], hgrad, rtol=tol)) else: print(i, "hgrad", hgrad, grad[i]) assert (isclose(grad[i], hgrad, rtol=tol))
def hyps_and_labels(self): return Parameters.get_hyps(self.hyps_mask, self.hyps, constraint=False, label=True)
def from_dict(hyps_mask, verbose=False, init_spec=[]): """convert dictionary mask to HM instance This function is not tested yet """ Parameters.check_instantiation( hyps_mask["hyps"], hyps_mask["cutoffs"], hyps_mask["kernels"], hyps_mask ) pm = ParameterHelper(verbose=verbose) nspecie = hyps_mask["nspecie"] if nspecie > 1: max_species = np.max(hyps_mask["specie_mask"]) specie_mask = hyps_mask["specie_mask"] for i in range(max_species + 1): elelist = np.where(specie_mask == i)[0] if len(elelist) > 0: for ele in elelist: if ele != 0: elename = Z_to_element(ele) if len(init_spec) > 0: if elename in init_spec: pm.define_group("specie", i, [elename]) else: pm.define_group("specie", i, [elename]) else: pm.define_group("specie", i, ["*"]) for kernel in hyps_mask["kernels"] + ParameterHelper.cutoff_types_keys: n = hyps_mask.get("n" + kernel, 0) if n >= 0: if kernel not in ParameterHelper.cutoff_types: chyps, copt = Parameters.get_component_hyps( hyps_mask, kernel, constraint=True, noise=False ) sig = chyps[0] ls = chyps[1] csig = copt[0] cls = copt[1] cutoff = hyps_mask["cutoffs"][kernel] pm.set_parameters("cutoff_" + kernel, cutoff) cutoff_list = hyps_mask.get( f"{kernel}_cutoff_list", np.ones(len(sig)) * cutoff ) elif kernel in ParameterHelper.cutoff_types and n > 1: cutoff_list = hyps_mask[ ParameterHelper.cutoff_types[kernel] + "_cutoff_list" ] if n > 1: all_specie = np.arange(nspecie) all_comb = combinations_with_replacement( all_specie, ParameterHelper.ndim[kernel] ) for comb in all_comb: mask_id = 0 for ele in comb: mask_id += ele mask_id *= nspecie mask_id = mask_id // nspecie ttype = hyps_mask[f"{kernel}_mask"][mask_id] pm.define_group(f"{kernel}", f"{kernel}{ttype}", comb) if (kernel not in ParameterHelper.cutoff_types) and ( kernel not in ParameterHelper.cutoff_types_values ): pm.set_parameters( f"{kernel}{ttype}", [sig[ttype], ls[ttype], cutoff_list[ttype]], opt=[csig[ttype], cls[ttype]], ) elif kernel in ParameterHelper.cutoff_types_values: pm.set_parameters( f"{kernel}{ttype}", [sig[ttype], ls[ttype]], opt=[csig[ttype], cls[ttype]], ) else: pm.set_parameters(f"{kernel}{ttype}", cutoff_list[ttype]) else: pm.define_group( kernel, kernel, ["*"] * ParameterHelper.ndim[kernel] ) if kernel not in ParameterHelper.cutoff_types_keys: pm.set_parameters( kernel, parameters=np.hstack([sig, ls, cutoff]), opt=copt ) else: pm.set_parameters(kernel, parameters=cutoff) hyps = Parameters.get_hyps(hyps_mask) pm.set_parameters("noise", hyps[-1]) if "cutoffs" in hyps_mask: cutoffs = hyps_mask["cutoffs"] for k in cutoffs: pm.set_parameters(f"cutoff_{k}", cutoffs[k]) return pm
def rbcm_get_neg_like( hyps, n_experts, name, force_kernel, logger_name, cutoffs, hyps_mask, n_cpus, n_sample, per_expert_parallel, ): neg_like = 0 neg_like_grad = None logger = logging.getLogger(logger_name) time0 = time.time() if per_expert_parallel and n_cpus > 1: with mp.Pool(processes=n_cpus) as pool: results = [] for i in range(n_experts): results.append( pool.apply_async( get_neg_like, ( hyps, f"{name}_{i}", force_kernel, logger_name, cutoffs, hyps_mask, 1, n_sample, ), )) for i in range(n_experts): chunk = results[i].get() neg_like_ = chunk neg_like += neg_like_ pool.close() pool.join() else: for i in range(n_experts): neg_like_ = get_neg_like( hyps, f"{name}_{i}", force_kernel, logger_name, cutoffs, hyps_mask, n_cpus, n_sample, ) neg_like += neg_like_ logger.info("") logger.info(f"Hyperparameters: {list(hyps)}") logger.info(f"Total Likelihood: {-neg_like}") logger.info(f"One step {time.time()-time0}") ohyps, label = Parameters.get_hyps(hyps_mask, hyps, constraint=False, label=True) if label: logger.info(f"oHyp_array: {list(ohyps)}") for i, l in enumerate(label): logger.info(f"oHyp {l}: {ohyps[i]}") return neg_like