def test_constraints1():
'''
simplest senario
'''
pm = ParameterHelper(species=['O', 'C', 'H'],
kernels={'twobody': [['*', '*'], ['O', 'O']],
'threebody': [['*', '*', '*'], ['O', 'O', 'O']]},
parameters={'twobody0': [1, 0.5], 'twobody1': [2, 0.2],
'threebody0': [1, 0.5], 'threebody1': [2, 0.2],
'cutoff_twobody': 2, 'cutoff_threebody': 1},
constraints={'twobody0': [True, False],
'threebody0': [False, True],
'noise': False},
verbose="DEBUG")
hm = pm.as_dict()
Parameters.check_instantiation(
hm['hyps'], hm['cutoffs'], hm['kernels'], hm)
assert hm['train_noise'] is False
hyps = hm['hyps']
assert len(hyps) == 6
assert hyps[0] == 1
assert hyps[1] == 2
assert hyps[2] == 0.2
assert hyps[3] == 2
assert hyps[4] == 0.5
assert hyps[5] == 0.2
def test_generate_by_line():
pm = ParameterHelper(verbose="DEBUG")
pm.define_group('specie', 'O', ['O'])
pm.define_group('specie', 'C', ['C'])
pm.define_group('specie', 'H', ['H'])
pm.define_group('twobody', '**', ['C', 'H'])
pm.define_group('twobody', 'OO', ['O', 'O'], atomic_str=True)
pm.define_group('threebody', '***', ['O', 'O', 'C'])
pm.define_group('threebody', 'OOO', ['O', 'O', 'O'])
pm.define_group('manybody', '1.5', ['C', 'H'])
pm.define_group('manybody', '1.5', ['C', 'O'])
pm.define_group('manybody', '1.5', ['O', 'H'])
pm.define_group('manybody', '2', ['O', 'O'])
pm.define_group('manybody', '2', ['H', 'O'])
pm.define_group('manybody', '2.8', ['O', 'O'])
pm.set_parameters('**', [1, 0.5])
pm.set_parameters('OO', [1, 0.5])
pm.set_parameters('***', [1, 0.5])
pm.set_parameters('OOO', [1, 0.5])
pm.set_parameters('1.5', [1, 0.5, 1.5])
pm.set_parameters('2', [1, 0.5, 2])
pm.set_parameters('2.8', [1, 0.5, 2.8])
pm.set_constraints('2', [True, False])
pm.set_constraints('2.8', False)
pm.set_parameters('cutoff_twobody', 5)
pm.set_parameters('cutoff_threebody', 4)
pm.set_parameters('cutoff_manybody', 3)
hm = pm.as_dict()
Parameters.check_instantiation(
hm['hyps'], hm['cutoffs'], hm['kernels'], hm)
def test_generate_by_line():
pm = ParameterHelper(verbose="DEBUG")
pm.define_group("specie", "O", ["O"])
pm.define_group("specie", "C", ["C"])
pm.define_group("specie", "H", ["H"])
pm.define_group("twobody", "**", ["C", "H"])
pm.define_group("twobody", "OO", ["O", "O"], atomic_str=True)
pm.define_group("threebody", "***", ["O", "O", "C"])
pm.define_group("threebody", "OOO", ["O", "O", "O"])
pm.define_group("manybody", "1.5", ["C", "H"])
pm.define_group("manybody", "1.5", ["C", "O"])
pm.define_group("manybody", "1.5", ["O", "H"])
pm.define_group("manybody", "2", ["O", "O"])
pm.define_group("manybody", "2", ["H", "O"])
pm.define_group("manybody", "2.8", ["O", "O"])
pm.set_parameters("**", [1, 0.5])
pm.set_parameters("OO", [1, 0.5])
pm.set_parameters("***", [1, 0.5])
pm.set_parameters("OOO", [1, 0.5])
pm.set_parameters("1.5", [1, 0.5, 1.5])
pm.set_parameters("2", [1, 0.5, 2])
pm.set_parameters("2.8", [1, 0.5, 2.8])
pm.set_constraints("2", [True, False])
pm.set_constraints("2.8", False)
pm.set_parameters("cutoff_twobody", 5)
pm.set_parameters("cutoff_threebody", 4)
pm.set_parameters("cutoff_manybody", 3)
hm = pm.as_dict()
Parameters.check_instantiation(hm["hyps"], hm["cutoffs"], hm["kernels"], hm)
def test_initialization5():
"""check universal"""
pm = ParameterHelper(
species=["O", "C", "H"],
kernels={
"twobody": [["*", "*"], ["O", "O"]],
"threebody": [["*", "*", "*"], ["O", "O", "O"]],
},
parameters={
"sigma": 1,
"lengthscale": 0.5,
"cutoff_threebody": 3,
"cutoff_twobody": 2,
},
verbose="DEBUG",
)
hm = pm.as_dict()
Parameters.check_instantiation(hm["hyps"], hm["cutoffs"], hm["kernels"], hm)
pm = ParameterHelper(
kernels=["twobody", "threebody"],
parameters={
"sigma": 1.0,
"lengthscale": 0.5,
"cutoff_twobody": 2,
"cutoff_threebody": 1,
"noise": 0.05,
},
verbose="DEBUG",
)
hm = pm.as_dict()
Parameters.check_instantiation(hm["hyps"], hm["cutoffs"], hm["kernels"], hm)
def test_generate_by_list():
pm = ParameterHelper(verbose="DEBUG")
pm.list_groups('specie', ['O', ['C', 'N'], 'H'])
pm.list_groups('twobody', [['*', '*'], ['O', 'O']])
pm.list_groups('threebody', [['*', '*', '*'], ['O', 'O', 'O']])
pm.list_parameters({'twobody0': [1, 0.5], 'twobody1': [2, 0.2],
'threebody0': [1, 0.5], 'threebody1': [2, 0.2],
'cutoff_twobody': 2, 'cutoff_threebody': 1})
hm = pm.as_dict()
Parameters.check_instantiation(
hm['hyps'], hm['cutoffs'], hm['kernels'], hm)
def test_opt():
pm = ParameterHelper(species=['O', 'C', 'H'],
kernels={'twobody': [['*', '*'], ['O', 'O']],
'threebody': [['*', '*', '*'], ['O', 'O', 'O']]},
parameters={'twobody0': [1, 0.5, 1], 'twobody1': [2, 0.2, 2],
'threebody0': [1, 0.5], 'threebody1': [2, 0.2],
'cutoff_twobody': 2, 'cutoff_threebody': 1},
constraints={'twobody0': [False, True]},
verbose="DEBUG")
hm = pm.as_dict()
Parameters.check_instantiation(
hm['hyps'], hm['cutoffs'], hm['kernels'], hm)
def test_initialization3():
"""check group definition"""
pm = ParameterHelper(species=['O', 'C', 'H'],
kernels={'twobody': [['*', '*'], ['O', 'O']],
'threebody': [['*', '*', '*'], ['O', 'O', 'O']]},
parameters={'twobody0': [1, 0.5], 'twobody1': [2, 0.2],
'threebody0': [1, 0.5], 'threebody1': [2, 0.2],
'cutoff_twobody': 2, 'cutoff_threebody': 1},
verbose="DEBUG")
hm = pm.as_dict()
Parameters.check_instantiation(
hm['hyps'], hm['cutoffs'], hm['kernels'], hm)
def test_initialization2(ones):
"""
check ones, random
"""
pm = ParameterHelper(
kernels=["twobody", "threebody"],
parameters={"cutoff_twobody": 2, "cutoff_threebody": 1, "noise": 0.05},
ones=ones,
random=not ones,
verbose="DEBUG",
)
hm = pm.as_dict()
Parameters.check_instantiation(hm["hyps"], hm["cutoffs"], hm["kernels"], hm)
def test_initialization2(ones):
'''
check ones, random
'''
pm = ParameterHelper(kernels=['twobody', 'threebody'],
parameters={'cutoff_twobody': 2,
'cutoff_threebody': 1,
'noise': 0.05},
ones=ones,
random=not ones,
verbose="DEBUG")
hm = pm.as_dict()
Parameters.check_instantiation(
hm['hyps'], hm['cutoffs'], hm['kernels'], hm)
def test_initialization():
'''
simplest senario
'''
pm = ParameterHelper(kernels=['twobody', 'threebody'],
parameters={'twobody': [1, 0.5],
'threebody': [1, 0.5],
'cutoff_twobody': 2,
'cutoff_threebody': 1,
'noise': 0.05},
verbose="DEBUG")
hm = pm.as_dict()
Parameters.check_instantiation(
hm['hyps'], hm['cutoffs'], hm['kernels'], hm)
def test_from_dict():
pm = ParameterHelper(
species=["O", "C", "H"],
kernels=["twobody", "threebody"],
allseparate=True,
random=True,
parameters={"cutoff_twobody": 7, "cutoff_threebody": 4.5, "cutoff_manybody": 3},
verbose="debug",
)
hm = pm.as_dict()
Parameters.check_instantiation(hm["hyps"], hm["cutoffs"], hm["kernels"], hm)
pm1 = ParameterHelper.from_dict(hm, verbose="debug", init_spec=["O", "C", "H"])
hm1 = pm1.as_dict()
Parameters.compare_dict(hm, hm1)
def test_initialization():
"""
simplest senario
"""
pm = ParameterHelper(
kernels=["twobody", "threebody"],
parameters={
"twobody": [1, 0.5],
"threebody": [1, 0.5],
"cutoff_twobody": 2,
"cutoff_threebody": 1,
"noise": 0.05,
},
verbose="DEBUG",
)
hm = pm.as_dict()
Parameters.check_instantiation(hm["hyps"], hm["cutoffs"], hm["kernels"], hm)
def test_generate_by_line2():
pm = ParameterHelper(verbose="DEBUG")
pm.define_group("specie", "O", ["O"])
pm.define_group("specie", "rest", ["C", "H"])
pm.define_group("twobody", "**", ["*", "*"])
pm.define_group("twobody", "OO", ["O", "O"])
pm.define_group("threebody", "***", ["*", "*", "*"])
pm.define_group("threebody", "Oall", ["O", "O", "O"])
pm.set_parameters("**", [1, 0.5])
pm.set_parameters("OO", [1, 0.5])
pm.set_parameters("Oall", [1, 0.5])
pm.set_parameters("***", [1, 0.5])
pm.set_parameters("cutoff_twobody", 5)
pm.set_parameters("cutoff_threebody", 4)
hm = pm.as_dict()
Parameters.check_instantiation(hm["hyps"], hm["cutoffs"], hm["kernels"], hm)
def test_from_dict():
pm = ParameterHelper(species=['O', 'C', 'H'],
kernels=['twobody', 'threebody'],
allseparate=True,
random=True,
parameters={'cutoff_twobody': 7,
'cutoff_threebody': 4.5,
'cutoff_manybody': 3},
verbose="debug")
hm = pm.as_dict()
Parameters.check_instantiation(
hm['hyps'], hm['cutoffs'], hm['kernels'], hm)
pm1 = ParameterHelper.from_dict(
hm, verbose="debug", init_spec=['O', 'C', 'H'])
hm1 = pm1.as_dict()
Parameters.compare_dict(hm, hm1)
def test_generate_by_list2():
pm = ParameterHelper(verbose="DEBUG")
pm.list_groups("specie", {"s1": "O", "s2": ["C", "N"], "s3": "H"})
pm.list_groups("twobody", {"t0": ["*", "*"], "t1": [["s1", "s1"], ["s1", "s3"]]})
pm.list_groups("threebody", [["*", "*", "*"], ["s1", "s1", "s1"]])
pm.list_parameters(
{
"t0": [1, 0.5],
"t1": [2, 0.2],
"threebody0": [1, 0.5],
"threebody1": [2, 0.2],
"cutoff_twobody": 2,
"cutoff_threebody": 1,
}
)
hm = pm.as_dict()
Parameters.check_instantiation(hm["hyps"], hm["cutoffs"], hm["kernels"], hm)
def test_generate_by_line2():
pm = ParameterHelper(verbose="DEBUG")
pm.define_group('specie', 'O', ['O'])
pm.define_group('specie', 'rest', ['C', 'H'])
pm.define_group('twobody', '**', ['*', '*'])
pm.define_group('twobody', 'OO', ['O', 'O'])
pm.define_group('threebody', '***', ['*', '*', '*'])
pm.define_group('threebody', 'Oall', ['O', 'O', 'O'])
pm.set_parameters('**', [1, 0.5])
pm.set_parameters('OO', [1, 0.5])
pm.set_parameters('Oall', [1, 0.5])
pm.set_parameters('***', [1, 0.5])
pm.set_parameters('cutoff_twobody', 5)
pm.set_parameters('cutoff_threebody', 4)
hm = pm.as_dict()
Parameters.check_instantiation(
hm['hyps'], hm['cutoffs'], hm['kernels'], hm)
def test_constraints2():
'''
simplest senario
'''
pm = ParameterHelper(kernels=['twobody', 'threebody'],
parameters={'twobody': [1, 0.5],
'threebody': [1, 0.5],
'cutoff_twobody': 2,
'cutoff_threebody': 1,
'noise': 0.05},
constraints={'twobody': [True, False]},
verbose="DEBUG")
hm = pm.as_dict()
Parameters.check_instantiation(
hm['hyps'], hm['cutoffs'], hm['kernels'], hm)
hyps = hm['hyps']
assert hyps[0] == 1
assert hyps[1] == 1
def check_instantiation(self):
"""
Runs a series of checks to ensure that the user has not supplied
contradictory arguments which will result in undefined behavior
with multiple hyperparameters.
:return:
"""
if self.logger_name is None:
if self.output is None:
self.logger_name = self.name + "GaussianProcess"
set_logger(
self.logger_name,
stream=True,
fileout_name=None,
verbose=self.verbose,
)
else:
self.logger_name = self.output.basename + "log"
logger = logging.getLogger(self.logger_name)
# check whether it's be loaded before
loaded = False
if self.name + "_0" in _global_training_labels:
if (_global_training_labels.get(self.name + "_0", None)
is not self.training_labels_np):
loaded = True
if self.name + "_0" in _global_energy_labels:
if (_global_energy_labels.get(self.name + "_0", None)
is not self.energy_labels_np):
loaded = True
if loaded:
base = f"{self.name}"
count = 2
while self.name + "_0" in _global_training_labels and count < 100:
time.sleep(random())
self.name = f"{base}_{count}"
logger.debug("Specified GP name is present in global memory; "
"Attempting to rename the "
f"GP instance to {self.name}")
count += 1
if self.name + "_0" in _global_training_labels:
milliseconds = int(round(time.time() * 1000) % 10000000)
self.name = f"{base}_{milliseconds}"
logger.debug(
"Specified GP name still present in global memory: "
f"renaming the gp instance to {self.name}")
logger.debug(f"Final name of the gp instance is {self.name}")
self.sync_data()
self.hyps_mask = Parameters.check_instantiation(
self.hyps, self.cutoffs, self.kernels, self.hyps_mask)
def test_opt():
pm = ParameterHelper(
species=["O", "C", "H"],
kernels={
"twobody": [["*", "*"], ["O", "O"]],
"threebody": [["*", "*", "*"], ["O", "O", "O"]],
},
parameters={
"twobody0": [1, 0.5, 1],
"twobody1": [2, 0.2, 2],
"threebody0": [1, 0.5],
"threebody1": [2, 0.2],
"cutoff_twobody": 2,
"cutoff_threebody": 1,
},
constraints={"twobody0": [False, True]},
verbose="DEBUG",
)
hm = pm.as_dict()
Parameters.check_instantiation(hm["hyps"], hm["cutoffs"], hm["kernels"], hm)
def test_initialization3():
"""check group definition"""
pm = ParameterHelper(
species=["O", "C", "H"],
kernels={
"twobody": [["*", "*"], ["O", "O"]],
"threebody": [["*", "*", "*"], ["O", "O", "O"]],
},
parameters={
"twobody0": [1, 0.5],
"twobody1": [2, 0.2],
"threebody0": [1, 0.5],
"threebody1": [2, 0.2],
"cutoff_twobody": 2,
"cutoff_threebody": 1,
},
verbose="DEBUG",
)
hm = pm.as_dict()
Parameters.check_instantiation(hm["hyps"], hm["cutoffs"], hm["kernels"], hm)
def test_constraints2():
"""
simplest senario
"""
pm = ParameterHelper(
kernels=["twobody", "threebody"],
parameters={
"twobody": [1, 0.5],
"threebody": [1, 0.5],
"cutoff_twobody": 2,
"cutoff_threebody": 1,
"noise": 0.05,
},
constraints={"twobody": [True, False]},
verbose="DEBUG",
)
hm = pm.as_dict()
Parameters.check_instantiation(hm["hyps"], hm["cutoffs"], hm["kernels"], hm)
hyps = hm["hyps"]
assert hyps[0] == 1
assert hyps[1] == 1
def test_initialization5():
"""check universal"""
pm = ParameterHelper(species=['O', 'C', 'H'],
kernels={'twobody': [['*', '*'], ['O', 'O']],
'threebody': [['*', '*', '*'], ['O', 'O', 'O']]},
parameters={'sigma': 1, 'lengthscale': 0.5, 'cutoff_threebody': 3,
'cutoff_twobody': 2},
verbose="DEBUG")
hm = pm.as_dict()
Parameters.check_instantiation(
hm['hyps'], hm['cutoffs'], hm['kernels'], hm)
pm = ParameterHelper(kernels=['twobody', 'threebody'],
parameters={'sigma': 1.0, 'lengthscale': 0.5,
'cutoff_twobody': 2,
'cutoff_threebody': 1,
'noise': 0.05},
verbose="DEBUG")
hm = pm.as_dict()
Parameters.check_instantiation(
hm['hyps'], hm['cutoffs'], hm['kernels'], hm)
def test_initialization_allsep(ones):
'''
check ones, random
'''
specie_list = ['C', 'H', 'O']
pm = ParameterHelper(species=specie_list,
kernels=['twobody', 'threebody'],
parameters={'cutoff_twobody': 2,
'cutoff_threebody': 1,
'noise': 0.05},
allseparate=True,
ones=ones,
random=not ones,
verbose="DEBUG")
hm = pm.as_dict()
Parameters.check_instantiation(
hm['hyps'], hm['cutoffs'], hm['kernels'], hm)
name_list = []
for i in range(3):
name = pm.find_group('specie', specie_list[i])
assert name not in name_list
name_list += [name]
name_list = []
for i in range(3):
for j in range(i, 3):
name = pm.find_group('twobody', [specie_list[i], specie_list[j]])
assert name not in name_list
name_list += [name]
with raises(RuntimeError):
pm = ParameterHelper(species=[],
kernels=['twobody', 'threebody'],
parameters={'cutoff_twobody': 2,
'cutoff_threebody': 1,
'noise': 0.05},
allseparate=True,
ones=ones,
random=not ones)
def test_initialization_allsep(ones):
"""
check ones, random
"""
specie_list = ["C", "H", "O"]
pm = ParameterHelper(
species=specie_list,
kernels=["twobody", "threebody"],
parameters={"cutoff_twobody": 2, "cutoff_threebody": 1, "noise": 0.05},
allseparate=True,
ones=ones,
random=not ones,
verbose="DEBUG",
)
hm = pm.as_dict()
Parameters.check_instantiation(hm["hyps"], hm["cutoffs"], hm["kernels"], hm)
name_list = []
for i in range(3):
name = pm.find_group("specie", specie_list[i])
assert name not in name_list
name_list += [name]
name_list = []
for i in range(3):
for j in range(i, 3):
name = pm.find_group("twobody", [specie_list[i], specie_list[j]])
assert name not in name_list
name_list += [name]
with raises(RuntimeError):
pm = ParameterHelper(
species=[],
kernels=["twobody", "threebody"],
parameters={"cutoff_twobody": 2, "cutoff_threebody": 1, "noise": 0.05},
allseparate=True,
ones=ones,
random=not ones,
)
def test_constraints1():
"""
simplest senario
"""
pm = ParameterHelper(
species=["O", "C", "H"],
kernels={
"twobody": [["*", "*"], ["O", "O"]],
"threebody": [["*", "*", "*"], ["O", "O", "O"]],
},
parameters={
"twobody0": [1, 0.5],
"twobody1": [2, 0.2],
"threebody0": [1, 0.5],
"threebody1": [2, 0.2],
"cutoff_twobody": 2,
"cutoff_threebody": 1,
},
constraints={
"twobody0": [True, False],
"threebody0": [False, True],
"noise": False,
},
verbose="DEBUG",
)
hm = pm.as_dict()
Parameters.check_instantiation(hm["hyps"], hm["cutoffs"], hm["kernels"], hm)
assert hm["train_noise"] is False
hyps = hm["hyps"]
assert len(hyps) == 6
assert hyps[0] == 1
assert hyps[1] == 2
assert hyps[2] == 0.2
assert hyps[3] == 2
assert hyps[4] == 0.5
assert hyps[5] == 0.2
def check_instantiation(self):
"""
Runs a series of checks to ensure that the user has not supplied
contradictory arguments which will result in undefined behavior
with multiple hyperparameters.
:return:
"""
logger = logging.getLogger(self.logger_name)
# check whether it's be loaded before
loaded = False
if self.name in _global_training_labels:
if _global_training_labels.get(self.name,
None) is not self.training_labels_np:
loaded = True
if self.name in _global_energy_labels:
if _global_energy_labels.get(self.name,
None) is not self.energy_labels_np:
loaded = True
if loaded:
base = f'{self.name}'
count = 2
while self.name in _global_training_labels and count < 100:
time.sleep(random())
self.name = f'{base}_{count}'
logger.debug("Specified GP name is present in global memory; "
"Attempting to rename the "
f"GP instance to {self.name}")
count += 1
if self.name in _global_training_labels:
milliseconds = int(round(time.time() * 1000) % 10000000)
self.name = f"{base}_{milliseconds}"
logger.debug(
"Specified GP name still present in global memory: "
f"renaming the gp instance to {self.name}")
logger.debug(f"Final name of the gp instance is {self.name}")
self.sync_data()
self.hyps_mask = Parameters.check_instantiation(
hyps=self.hyps, cutoffs=self.cutoffs, kernels=self.kernels,
param_dict=self.hyps_mask)
self.bounds = deepcopy(self.hyps_mask.get('bounds', None))
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
