def get_X_sym(self, split_operator=Identity()):
"""
gets the simbolic expression of X
:return:
"""
sym_X = self.X_operator(split_operator * self.sym_field, split_operator * self.sym_regressors if self.sym_regressors != [] else self.sym_regressors)
return self.filter_ysymvars_in_Xsymvars(self.get_y_sym(split_operator), x_field=sym_X)
def get_y_sym(self, split_operator=Identity()):
"""
gets the simbolic expression of y
:return:
"""
return self.y_operator(split_operator * self.sym_field)
def get_y_dframe(self, split_operator=Identity()):
return self.get_y(split_operator).to_pandas()
def get_y(self, split_operator=Identity()):
return self.y_operator(split_operator * self.field)
def get_X(self, split_operator=Identity()):
X = self.X_operator(split_operator * self.field,
split_operator * self.regressors if self.sym_regressors != [] else self.regressors)
return self.filter_yvars_in_Xvars(self.get_y(split_operator), x_field=X)
def explore_phase_diagram(self, prediction_methods, derivative_in_y, derivatives_in_x, poly_degree, rational=False,
method_label_dict={}, reload=True, starting_point={"t": 0}, prediction_methods2plot=None,
getXfunc=get_x_operator_func):
# ---------- save params of experiment ----------
self.experiments.append({'explore_phase_diagram': {
'date': datetime.now(),
'prediction_methods': prediction_methods,
'derivative_in_y': derivative_in_y,
'derivatives_in_x': derivatives_in_x,
'poly_degree': poly_degree}
})
subfolders = ['phase_diagram']
# ----------------------------------------
prediction_methods = list(sorted(prediction_methods))
if prediction_methods2plot is None:
prediction_methods2plot = prediction_methods
data_manager = self.get_data_manager()
data_manager.set_X_operator(getXfunc(derivatives_in_x, poly_degree, rational))
data_manager.set_y_operator(get_y_operator_func(self.get_derivative_in_y(derivative_in_y, derivatives_in_x)))
# ---------- fit eqdiff ----------
pde_finder = self.fit_eqdifff(data_manager)
base_name = 'dery{}_derx{}_poly{}'.format(derivative_in_y, derivatives_in_x, poly_degree)
# pde_finder = self.load_fitsave_eqdifff(self, data_manager)
with savefig('coeficients_{}_dery{}_derx{}_poly{}'.format('_'.join(prediction_methods), derivative_in_y,
derivatives_in_x, poly_degree), self.experiment_name,
subfolders=subfolders):
self.plot_coefficients(pde_finder)
# ---------- predictions ----------
predictions = load_csv('phase_diagram_predictions_data', self.experiment_name, subfolders=subfolders)
if predictions is not None and not reload and predictions.method.isin(prediction_methods).any():
predictions = predictions.loc[~predictions.method.isin(prediction_methods), :]
for i, prediction_method in enumerate(prediction_methods):
if not reload or (reload and prediction_method not in predictions.method.unique()):
df_predictions = pde_finder.integrate2(dm=data_manager,
dery=derivatives_in_x - derivative_in_y if derivative_in_y < 0 else derivative_in_y,
starting_point=starting_point,
horizon=self.phase_diagram_horizon,
method=prediction_method)
df_predictions['method'] = prediction_method
predictions = pd.concat([predictions if predictions is not None else
pd.DataFrame([], columns=df_predictions.columns)] + [df_predictions])
real = evaluator.get_real_values([Identity()],
dm=data_manager,
starting_point=starting_point,
domain_variable2predict='t',
horizon=self.phase_diagram_horizon)
real = pd.concat(real)
real = real.reset_index()
real['method'] = 'real'
print(predictions)
save_csv(real, 'phase_diagram_real_data', self.experiment_name, subfolders=subfolders)
save_csv(predictions, 'phase_diagram_predictions_data', self.experiment_name, subfolders=subfolders)
# if we want to append new methods.
prediction_methods = set(predictions.method.unique()).intersection(set(prediction_methods2plot))
method_colors = {pred_method: self.colors[i] for i, pred_method in enumerate(prediction_methods)}
# ---------- evaluate statistics ----------
for var in data_manager.field.data:
var_name = var.get_full_name()
# ---------- plot phase diagram ----------
with savefig('phase_diagram_{}_{}'.format(var_name, '-'.join(prediction_methods)), self.experiment_name,
subfolders=subfolders):
fig, allax = plt.subplots(nrows=len(prediction_methods),
figsize=(15, len(prediction_methods) * 15), sharex=True)
for i, (method, df) in enumerate(
predictions.loc[predictions.method.isin(prediction_methods), :].groupby('method')):
ax = allax if len(prediction_methods) == 1 else allax[i]
x, dx = self.plot_phase_diagram(real[var_name].values.ravel(),
dx=data_manager.domain.step_width['t'],
method='real', var_name=var_name, color='black', ax=ax)
ax.set_xlim((np.min(x) - (np.max(x) - np.min(x)) / 2, np.max(x) + (np.max(x) - np.min(x)) / 2))
ax.set_ylim(
(np.min(dx) - (np.max(dx) - np.min(dx)) / 2, np.max(dx) + (np.max(dx) - np.min(dx)) / 2))
self.plot_phase_diagram(df[var_name].values.ravel(), dx=data_manager.domain.step_width['t'],
method=method, var_name=var_name,
color=method_colors[method], ax=ax)
ax.legend()
plt.close("all")
# ---------- plot series ----------
with savefig('predictions_{}_{}'.format(var_name, '-'.join(prediction_methods)), self.experiment_name,
subfolders=subfolders):
fig, allax = plt.subplots(nrows=len(prediction_methods),
figsize=(15, len(prediction_methods) * 15), sharex=True)
for i, (method, df) in enumerate(
predictions.loc[predictions.method.isin(prediction_methods), :].groupby('method')):
ax = allax if len(prediction_methods) == 1 else allax[i]
real_series = real[var_name].values.ravel()
ax.plot(real['index'].values.ravel() * data_manager.domain.step_width['t'],
real[var_name].values.ravel(), label='real', c='black')
ax.set_ylim((np.min(real_series) - (np.max(real_series) - np.min(real_series)) / 2,
np.max(real_series) + (np.max(real_series) - np.min(real_series)) / 2))
ax.plot(real['index'].values.ravel() * data_manager.domain.step_width['t'],
df[var_name].values.ravel(), label='model',
c=method_colors[method])
ax.set_xlabel(data_manager.domain.axis_names[0], fontsize=20)
ax.set_ylabel(varname2latex(var_name, derivative=0), fontsize=20, rotation=0)
ax.legend()
plt.close("all")