def space(self):
raum = {}
for sp in self.results['space'].dimensions:
if sp.__class__.__name__ == 'Categorical':
_raum = {
k: Jsonize(v)()
for k, v in sp.__dict__.items()
if k in ['categories', 'transform_', 'prior', '_name']
}
_raum.update({'type': 'Categorical'})
raum[sp.name] = _raum
elif sp.__class__.__name__ == 'Integer':
_raum = {
k: Jsonize(v)()
for k, v in sp.__dict__.items() if k in [
'low', 'transform_', 'prior', '_name', 'high', 'base',
'dtype', 'log_base'
]
}
_raum.update({'type': 'Integer'})
raum[sp.name] = _raum
elif sp.__class__.__name__ == 'Real':
_raum = {
k: Jsonize(v)()
for k, v in sp.__dict__.items() if k in [
'low', 'transform_', 'prior', '_name', 'high', 'base',
'dtype', 'log_base'
]
}
_raum.update({'type': 'Real'})
raum[sp.name] = _raum
return raum
def y0(self):
__y0 = self.results['specs']['args']['y0']
if __y0 is None:
return __y0
if isinstance(__y0, list):
_y0 = []
for y in self.results['specs']['args']['y0']:
_y0.append(Jsonize(y)())
return _y0
return Jsonize(self.results['specs']['args']['y0'])()
def serialize(self):
_raum = {
k: Jsonize(v)()
for k, v in self.__dict__.items() if not callable(v)
}
_raum.update({'type': 'Integer'})
return _raum
def f(**kwargs):
kwargs['objective'] = 'reg:squarederror'
kwargs = Jsonize(kwargs)()
model = Model(inputs=inputs,
outputs=outputs,
lookback=1,
batches="2d",
val_data="same",
test_fraction=0.3,
model={"xgboostregressor": kwargs},
transformation=None,
data=data,
prefix='testing',
verbosity=0)
model.fit(indices="random")
t, p = model.predict(indices=model.test_indices, prefix='test')
mse = RegressionMetrics(t, p).mse()
print(f"Validation mse {mse}")
return mse
def x_iters(self):
out_x = []
for i in range(self.iters):
x = []
for para in self.results['x_iters'][i]:
x.append(Jsonize(para)())
out_x.append(x)
return out_x
def x0(self):
_x0 = []
__xo = self.results['specs']['args']['x0']
if __xo is not None:
for para in __xo:
if isinstance(para, list):
_x0.append(self.para_list(para))
else:
_x0.append(Jsonize(para)())
return _x0
def specs(self):
_specs = {}
_specs['function'] = self.results['specs']['function']
args = {}
args['func'] = str(self.results['specs']['args']['func'])
args['dimensions'] = self.space()
be = self.results['specs']['args']['base_estimator']
b_e = {
k: Jsonize(v)()
for k, v in be.__dict__.items() if k in [
'noise', 'alpha', 'optimizer', 'n_restarts_optimizer',
'normalize_y', 'copy_X_train', 'random_state'
]
}
b_e['kernel'] = self.kernel(be.kernel)
args['base_estimator'] = b_e
for k, v in self.results['specs']['args'].items():
if k in [
'n_cals', 'n_random_starts', 'n_initial_points',
'initial_point_generator', 'acq_func', 'acq_optimizer',
'verbose', 'callback', 'n_points', 'n_restarts_optimizer',
'xi', 'kappa', 'n_jobs', 'model_queue_size'
]:
args[k] = Jsonize(v)()
args['x0'] = self.x0()
args['y0'] = self.y0()
_specs['args'] = args
return _specs
def models(self):
mods = []
for model in self.results['models']:
mod = {
k: Jsonize(v)()
for k, v in model.__dict__.items() if k in [
'noise', 'alpha', 'optimizer', 'n_restarts_optimizer',
'normalize_y', 'copy_X_train', 'random_state', '_rng',
'n_features_in', '_y_tain_mean', '_y_train_std', 'X_train',
'y_train', 'log_marginal_likelihood', 'L_', 'K_inv',
'alpha', 'noise_', 'K_inv_', 'y_train_std_',
'y_train_mean_'
]
}
mod['kernel'] = self.kernel(model.kernel)
mods.append({model.__class__.__name__: mod})
return mods
def plot_feature_importance(self, importance=None, save=True, use_xgb=False, **kwargs):
if importance is None:
importance = self.feature_importance()
if self.model.category == "ML":
model_name = list(self.model.config['model'].keys())[0]
if model_name.upper() in ["SVC", "SVR"]:
if self._model.kernel == "linear":
return self.f_importances_svm(importance, self.model.in_cols, save=save)
else:
warnings.warn(f"for {self._model.kernel} kernels of {model_name}, feature importance can not be plotted.")
return
if isinstance(importance, np.ndarray):
assert importance.ndim <= 2
with open(os.path.join(self.model.path, 'feature_importance.json'), 'w') as fp:
json.dump(Jsonize(importance)(), fp)
use_prev = self.model.config['use_predicted_output']
all_cols = self.model.config['inputs'] if use_prev else self.model.config['inputs'] + \
self.model.config['outputs']
plt.close('all')
plt.figure()
plt.title("Feature importance")
if use_xgb:
if xgboost is None:
warnings.warn("install xgboost to plot plot_importance using xgboost", UserWarning)
else:
xgboost.plot_importance(self._model, **kwargs)
else:
plt.bar(range(self.model.ins if use_prev else self.model.ins + self.model.outs), importance, **kwargs)
plt.xticks(ticks=range(len(all_cols)), labels=list(all_cols), rotation=90, fontsize=12)
self.save_or_show(save, fname="feature_importance.png")
return
def test_jsonize_none(self):
a = [None]
b = Jsonize(a)()
self.assertTrue(isinstance(b, list))
self.assertTrue(isinstance(b[0], type(None)))
return
def test_jsonize_nested_dict(self):
a = {'a': {'b': {'c': {'d': {'e': np.array([2])}}}}}
b = Jsonize(a)()
self.assertTrue(isinstance(b, dict))
self.assertTrue(isinstance(b['a']['b']['c']['d']['e'], int))
return
def test_jsonize(self):
a = [np.array([2.0])]
b = Jsonize(a)()
self.assertTrue(isinstance(b, list))
self.assertTrue(isinstance(b[0], float))
return
def singleton_kernel(self, k):
"""Serializes Kernels such as Matern, White, Constant Kernels"""
return {k: Jsonize(v)() for k, v in k.__dict__.items()}
def para_list(self, x):
"""Serializes list of parameters"""
_x = []
for para in x:
_x.append(Jsonize(para)())
return _x