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